# https://pt.angie.software/angie/docs.md
# Sobre o Angie
Angie
/[andʒi](https://en.wikipedia.org/wiki/International_Phonetic_Alphabet)/
é um servidor web eficiente, poderoso e escalável
que foi derivado do nginx:
* Concebido por ex-desenvolvedores da equipe original
para ir além da visão anterior
e atuar como um [substituto direto](https://pt.angie.software//angie/docs/configuration/migration.md#migration)
sem grandes mudanças na configuração de módulos ou configuração.
* Inclui a maioria das capacidades do
[nginx 1.31.2](https://nginx.org/en/CHANGES)
e uma série de [novos recursos](#index-features-oss).
Construímos pacotes binários para uma variedade de
[sistemas e arquiteturas](https://pt.angie.software//angie/docs/installation/index.md#install-packages),
bem como
[imagens Docker](https://pt.angie.software//angie/docs/installation/docker.md#docker-images).
O código-fonte está aberto em nossos
[repositórios públicos](https://pt.angie.software//angie/docs/development.md#development)
sob uma
[licença similar à BSD](https://pt.angie.software//angie/license-angie.md#license-angie).
Além disso, uma versão comercial com [recursos adicionais](#index-features-pro)
é comercializada como Angie PRO.
Uma escolha de pacotes Angie prontos,
imagens Docker e opções de compilação do código-fonte.
Controle de inicialização e tempo de execução;
configuração, módulos, diretivas e variáveis.
Resolução de problemas técnicos com o Angie,
rotas de feedback disponíveis.
Informações para desenvolvedores
que desejam contribuir para o projeto.
## Versão Atual
**Angie 1.12.1** e **Angie PRO 1.12.1** foram lançados em **17 de julho de 2026**.
Novas versões aparecem trimestralmente;
no intervalo, publicamos correções urgentes e atualizações importantes.
Veja também o histórico completo de versões para
[Angie](https://pt.angie.software//angie/docs/oss_changes.md#oss-changes)
e
[Angie PRO](https://pt.angie.software//angie/docs/pro_changes.md#pro-changes).
## Vantagens do Angie sobre o nginx
Principais vantagens disponíveis
na versão gratuita de código aberto do Angie:
**Observabilidade e monitoramento**
- Exposição de informações básicas sobre o servidor web,
sua [configuração](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api-config-files),
bem como [métricas](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#metrics) de servidores com proxy, conexões de cliente,
zonas de memória compartilhada, certificados TLS e muitas outras coisas
através de uma interface [API](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api) RESTful em formato JSON.
- Coleta de [métricas personalizadas](https://pt.angie.software//angie/docs/configuration/custom-metrics.md#custom-metrics-config)
para tráfego [HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric) e [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#stream-metric) em tempo
real com o módulo Metric, usando métodos de agregação configuráveis (contadores,
histogramas, médias móveis e assim por diante); as métricas são agrupadas por
chaves arbitrárias e expostas através da API de estatísticas.
- Exportação de estatísticas no formato [Prometheus](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#id1)
com [modelos personalizáveis](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#prometheus-template).
- Registro de erros aprimorado com a diretiva [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log):
filtragem de mensagens com o parâmetro `filter=`, saída em JSON com
o parâmetro `format=` e uma taxa de registro configurável com o
parâmetro `rate=`, além de tags personalizadas por meio da
diretiva [error_log_user_tag](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#error-log-user-tag).
- Monitoramento do servidor através do navegador com a
ferramenta de monitoramento visual [Console Light](https://pt.angie.software//angie/docs/configuration/monitoring.md#monitoring).
Veja a demonstração online: [https://console.angie.software/](https://console.angie.software/)
**TLS e segurança**
- O cliente [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) no Angie, já habilitado em nossos pacotes e
imagens, de modo que não há módulo à parte para instalar: emissão e
renovação automáticas de certificados TLS com validação de domínio via
[HTTP, DNS e TLS-ALPN](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client). A validação via DNS abre caminho
para certificados wildcard, o ACME também funciona no módulo [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme), e métodos de validação não padronizados são conectados pela
diretiva [acme_hook](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-hook).
- Suporte a TLS 1.3 Early Data (0-RTT) no módulo `stream`
usando a diretiva [ssl_early_data](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-early-data).
- Suporte [do servidor](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-ntls) e [do cliente](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-ntls)
para NTLS ao usar a
biblioteca TLS [TongSuo](https://github.com/Tongsuo-Project/Tongsuo),
habilitada [no momento da compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#install-source-features).
**Proxy e balanceamento de carga**
- Atualização dinâmica de grupos upstream baseada em eventos e rótulos de
[contêineres Docker](https://pt.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker) (ou ferramentas similares como Podman) sem
recarregamento do servidor.
- Recomissionamento de servidores upstream após uma falha suavemente
usando a opção `slow_start` da diretiva [server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server),
tanto em upstreams HTTP quanto stream.
- [Fator de suavização](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) configurável do
balanceamento por [tempo médio de resposta](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-time): ele
determina o quanto as medições recentes influenciam a média, de uma média
inerte a uma reação rápida a picos.
- [Vinculação de sessão](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-sticky) para os protocolos do módulo
`stream` (TCP/UDP): todas as conexões dentro de uma sessão são
direcionadas para o mesmo servidor com proxy.
- Descomissionamento gradual de um servidor com proxy no módulo
`stream` através da opção `drain` da diretiva
[server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server): o servidor para de aceitar novas conexões, mas
continua atendendo as sessões já vinculadas a ele.
**Protocolos e tráfego**
- [HTTP/3](https://pt.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) nas conexões com [servidores com proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-http-version), e não apenas com os clientes: a versão do protocolo
(HTTP/1.x, HTTP/2, HTTP/3) é escolhida de forma independente em cada lado.
- Um servidor [DoH](https://pt.angie.software//angie/docs/configuration/modules/http/http_doh.md#http-doh) embutido (DNS over HTTPS, RFC 8484):
aceita consultas DNS por HTTP/HTTPS e as encaminha por proxy para grupos
de servidores DNS via UDP ou TCP.
- Extensão das capacidades de autorização e balanceamento para o protocolo MQTT
com a diretiva [mqtt_preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#s-mqtt-preread) sob `stream`.
- Informação das decisões de balanceamento com cookies de sessão do protocolo RDP
através da diretiva [rdp_preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#s-rdp-preread) sob `stream`.
- Limitação da [taxa de transferência de arquivos MP4](https://pt.angie.software//angie/docs/configuration/modules/http/http_mp4.md#mp4-limit-rate)
proporcionalmente ao seu bitrate,
reduzindo assim a carga de largura de banda.
- Envio do PROXY Protocol v2 para servidores com proxy no módulo
`stream`, com a possibilidade de definir valores TLV arbitrários
através da diretiva [proxy_protocol_tlv](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-protocol-tlv).
- Conversão de imagens entre formatos, incluindo para HEIC e AVIF,
com o parâmetro `convert` da diretiva [image_filter](https://pt.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#id1).
- Suporte aos [métodos de autenticação](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#m-smtp-auth) XOAUTH2 e
OAUTHBEARER no proxy de mail.
**Configuração e operação mais simples**
- Liberação da zona de memória compartilhada em [proxy_cache_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path) para
disco: o conteúdo do índice de cache é preservado entre reinicializações e
atualizações, o que elimina o atraso de carregamento do cache e coloca o
servidor online ainda mais rápido.
- Várias expressões de correspondência de uma vez em uma única diretiva
`location`: os blocos com configurações compartilhadas podem ser
[combinados](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#combined-locations).
- A diretiva [goto](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#goto) no módulo rewrite, que realiza um
redirecionamento interno para um location nomeado sem modificar a URI, no
lugar de soluções alternativas baseadas em `try_files` ou
`error_page`.
- Configuração automática do [resolver DNS](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver) a partir de
`/etc/resolv.conf`: o arquivo é relido quando é alterado,
eliminando a necessidade de especificar os endereços dos servidores DNS
manualmente.
- A diretiva [time_format](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#time-format), que define uma variável com um
formato de hora personalizado, suportando especificadores no estilo
`strftime()` e `%L` para milissegundos.
- [Pacotes binários](https://pt.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules) pré-construídos
para muitos módulos de terceiros populares.
## Recursos do Angie PRO
O Angie PRO comercial adiciona o seguinte
aos recursos da [versão de código aberto](#index-features-oss):
**Configuração dinâmica e gerenciamento**
- Gerenciamento de servidores com proxy através de uma [API](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-config)
RESTful de configuração dinâmica: os servidores podem entrar e sair do
balanceamento, e seus pesos e outros parâmetros podem ser alterados em
tempo real, sem recarregar os processos de trabalho. O console de
monitoramento visual
[Console Light](https://pt.angie.software//angie/docs/configuration/monitoring.md#monitoring) também pode ser usado para gerenciar o
servidor em seu navegador.
- Substituição da assinatura do servidor em páginas de erro e no campo de
cabeçalho `Server` por um valor arbitrário usando a diretiva
[server_tokens](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-tokens).
**Balanceamento avançado e tolerância a falhas**
- Balanceamento por [feedback](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-feedback): os pares são selecionados
pelo valor de uma variável; presume-se que ele venha dos próprios pares, que
relatam sua carga de CPU ou outras métricas.
- Fila de espera para solicitações, configurada usando a diretiva
[queue](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-queue) no bloco `upstream`: se nenhum servidor puder
ser escolhido para uma solicitação na primeira tentativa, por exemplo
durante um pico de carga, a solicitação entra na fila em vez de ser
rejeitada de imediato.
- Verificação proativa do estado de servidores com proxy enviando
[solicitações de sondagem](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe) periódicas: um servidor
com falha sai do balanceamento antes que uma solicitação de cliente chegue
até ele, e não depois.
- A diretiva [no_port](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-no-port) em um bloco `upstream` do
módulo `stream`, que desvincula a porta dos servidores do grupo: a
porta é indicada na diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-pass), de modo que um mesmo grupo
pode servir para proxy em portas diferentes sem duplicar a lista de
servidores.
- A diretiva [backup_switch](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-backup-switch) no bloco `upstream`:
os servidores de backup podem continuar servindo solicitações quando os
servidores primários se tornam acessíveis novamente.
**Sessões, conexões e cache**
- [Vinculação condicional de conexões de cliente](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-bind-conn)
à conexão do servidor com proxy, o que também permite proxy NTLM.
- A diretiva [proxy_bind](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-bind), que avalia as variáveis após cada seleção de
servidor com proxy: o endereço de saída pode depender do servidor
selecionado, por exemplo através da variável [$upstream_current_addr](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#v-upstream-current-addr).
- O modo [sticky learn](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky) com armazenamento de sessões em um
repositório externo, o que permite unir múltiplos balanceadores em um
cluster.
- Fragmentação de cache no módulo proxy, que permite distribuí-lo entre
[discos diferentes](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache) dependendo das propriedades da resposta.
# https://pt.angie.software/angie/docs/installation.md
# Instalação
## Angie
Várias opções de instalação estão disponíveis para a versão gratuita de código aberto:
| [Pacotes binários](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages) | Método de instalação recomendado; compilamos e publicamos pacotes para a maioria das distribuições Linux e FreeBSD.
Junto com isso, também preparamos e lançamos nossas próprias compilações para muitos [módulos populares de terceiros](https://pt.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules). |
|----------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Imagens Docker](https://pt.angie.software//angie/docs/installation/docker.md#docker-images) | Para executar em um contêiner, você pode baixar a imagem Docker do nosso registro. Compilamos imagens a partir dos nossos próprios pacotes com base em uma ampla gama de distribuições.
As imagens no registro contêm *todos* os módulos que compilamos, incluindo os de terceiros; há também uma imagem mínima sem módulos adicionais. |
| [Compilação a partir do código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild) | Se as opções anteriores não lhe servem por algum motivo, você sempre pode criar sua própria compilação a partir do código-fonte. |
Você pode sugerir novos métodos de instalação, módulos e distribuições
no
[fórum](https://forum.angie.support)
ou no
[GitHub](https://github.com/webserver-llc/angie/issues).
## Angie PRO
A principal opção de instalação para a versão comercial são
[pacotes binários](https://pt.angie.software//angie/docs/installation/pro_packages.md#pro-packages),
armazenados em um repositório privado seguro;
para acessá-lo, você precisa assinar um contrato e adquirir uma licença.
Compilações estão disponíveis para a maioria dos sistemas compatíveis com POSIX;
além disso, podemos criar e testar sua compilação
para uma distribuição e método de instalação específicos.
## Módulos de Terceiros e Outras Fontes
Preparamos e publicamos compilações para muitos
[módulos populares de terceiros](https://pt.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules) em nosso repositório.
Além disso, para vários sistemas operacionais e distribuições,
o Angie pode ser instalado a partir de seus
[próprios repositórios](https://pt.angie.software//angie/docs/installation/thirdparty.md#thirdparty).
# https://pt.angie.software/angie/docs/installation/oss_packages.md
# Instalação do Angie via Pacotes
Para instalar e atualizar o Angie
usando o gerenciador de pacotes da sua distribuição,
adicione e configure o repositório apropriado.
## Distribuições
| Nome | Versões | Arquiteturas |
|-----------------------------------|--------------------------------|-------------------------------|
| [AlmaLinux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [Alpine](#install-alpine-oss) | 3.23, 3.22, 3.21 | x86-64, arm64 |
| [Alt](#install-alt-oss) | 11, 10 8 | x86-64, arm64 x86-64 |
| [Astra SE](#install-astrase-oss) | 4.7 1.8, 1.7 | arm64 x86-64 |
| [CentOS](#install-yum-oss) | 10, 9 | x86-64, arm64 |
| [Debian](#install-deb-oss) | 13, 12, 11 | x86-64, arm64 |
| [Fedora](#install-yum-oss) | 44, 43 | x86-64, arm64 |
| [FreeBSD](#install-freebsd-oss) | 15, 14 | x86-64, arm64 |
| [MSVSphere](#install-yum-oss) | 10, 9 8 | x86-64, arm64 x86-64 |
| [openSUSE](#install-opensuse-oss) | 16, 15 | x86-64, arm64 |
| [Oracle Linux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [OSNova](#install-osnova-oss) | 3.3.0, 2.13 | x86-64 |
| [RED OS](#install-yum-oss) | 8, 7 | x86-64, arm64 |
| [Rocky Linux](#install-yum-oss) | 10, 9, 8 | x86-64, arm64 |
| [ROSA](#install-yum-oss) | Chrome 13 Chrome 12 Fresh 12 | x86-64 x86-64, arm64 x86-64 |
| [SberLinux](#install-yum-oss) | 9 | x86-64 |
| [Ubuntu](#install-deb-oss) | 26.04, 24.04, 22.04 | x86-64, arm64 |
### Builds de Teste
Testamos e compilamos código do nosso repositório diariamente,
e estes
[builds noturnos](https://download.angie.software/angie-nightly/)
são adequados para explorar novos recursos antes dos lançamentos oficiais.
A versão dos builds noturnos sempre corresponde ao próximo lançamento.
O processo de nomenclatura e instalação é geralmente similar ao mostrado abaixo,
mas ao invés do prefixo de caminho `https://download.angie.software/angie/*`
use `https://download.angie.software/angie-nightly/*`.
### Alma, CentOS, Fedora, MSVSphere, Oracle, RED OS, Rocky, ROSA, SberLinux
1. Para adicionar o repositório, crie um arquivo chamado
`/etc/yum.repos.d/angie.repo`
com o seguinte conteúdo:
Alma
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/almalinux/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
CentOS
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/centos/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Fedora
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/fedora/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
MSVSphere
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/msvsphere/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Oracle
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/oracle/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
RED OS
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/redos/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Rocky
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rocky/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Chrome
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rosa-chrome/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
ROSA Fresh
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/rosa/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
SberLinux
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/sberlinux/$releasever/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
priority=9
```
2. Instale o pacote Angie:
```console
$ sudo yum install -y angie
$ # -- OU --
$ sudo dnf install -y angie
```
3. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo yum install -y
$ # -- OU --
$ sudo dnf install -y
```
4. Inicie o serviço:
```console
$ sudo systemctl start angie
```
5. Para iniciar automaticamente o Angie após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
### Alpine
1. Instale os pré-requisitos
para adicionar o repositório do Angie:
```console
$ sudo apk update
$ sudo apk add curl ca-certificates
```
2. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /etc/apk/keys/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
3. Adicione o repositório do Angie:
```console
$ echo "https://download.angie.software/angie/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" \
| sudo tee -a /etc/apk/repositories > /dev/null
```
4. Atualize os índices do repositório:
```console
$ sudo apk update
```
5. Instale o pacote Angie:
```console
$ sudo apk add angie
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo apk add
```
7. Inicie o serviço:
```console
$ sudo service angie start
```
8. Para iniciar automaticamente o Angie após a reinicialização do servidor:
```console
$ sudo rc-update add angie
```
### Alt
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Instale os pré-requisitos
para adicionar o repositório do Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y curl apt-https
```
3. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /etc/ssl/angie/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
4. Importe a chave baixada para o chaveiro confiável:
```console
$ sudo gpg --no-default-keyring \
--keyring /usr/lib/alt-gpgkeys/pubring.gpg --import /etc/ssl/angie/angie-signing.gpg
```
5. Salve a assinatura da chave:
```sh
$ echo 'simple-key "angie" {
Fingerprint "EB8EAF3D4EF1B1ECF34865A2617AB978CB849A76";
Name "Angie (Signing Key) ";
}' | sudo tee /etc/apt/vendors.list.d/angie.list > /dev/null
```
6. Adicione o repositório do Angie:
Alt 11
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux/11/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt 10
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 10
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux-sp/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 8
```console
$ echo "rpm [angie] https://download.angie.software/angie/altlinux-sp/8/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
7. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
8. Instale o pacote do Angie:
```console
$ sudo apt-get install -y angie
```
9. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo apt-get install -y
```
10. Inicie o serviço:
```console
$ sudo systemctl start angie
```
11. Para inicializar automaticamente o Angie após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
### Astra SE
1. Instale os pré-requisitos
para adicionar o repositório do Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl lsb-release
```
2. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Adicione o repositório do Angie:
```console
$ echo "deb https://download.angie.software/angie/astra-se/$(egrep -o \
'[0-9]+.[0-9]+' /etc/astra_version) unstable main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
5. (*Opcional*) Ao executar um Ambiente de Software Fechado
([CSE](https://wiki.astralinux.ru/pages/viewpage.action?pageId=41190634)),
instale o pacote de chave
para verificação de binários do Angie:
```console
$ sudo apt-get install -y angie-digsig-key
```
Atualize o CSE:
```console
$ sudo update-initramfs -uk all
```
Em seguida, **reinicie o servidor**:
```console
$ sudo shutdown -r now
```
6. Instale o pacote do Angie:
```console
$ sudo apt-get install -y angie
```
7. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo apt-get install -y
```
### Debian, Ubuntu
1. Instale os pré-requisitos
para adicionar o repositório do Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Adicione o repositório do Angie:
```console
$ echo "deb https://download.angie.software/angie/$(. /etc/os-release && echo "$ID/$VERSION_ID $VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
5. Instale o pacote do Angie:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo apt-get install -y
```
### OSNova
1. Instale os pré-requisitos
para adicionar o repositório do Angie:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Adicione o repositório do Angie:
```console
$ echo "deb https://download.angie.software/angie/osnova/$(egrep -o \
'[0-9]*' /etc/osnova_version | head -1) \
$(. /etc/os-release && echo "$VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
5. Instale o pacote do Angie:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo apt-get install -y
```
### FreeBSD
1. Para adicionar o repositório do Angie, crie os diretórios:
```console
$ sudo mkdir -p /usr/local/etc/pkg/angie/ /usr/local/etc/pkg/repos/
```
2. Para configurar o repositório, crie um arquivo chamado
`/usr/local/etc/pkg/repos/angie.conf`
com o seguinte conteúdo:
```console
angie: {
url: "https://download.angie.software/angie/freebsd/${VERSION_MAJOR}/${ARCH}",
signature_type: "pubkey",
pubkey: "/usr/local/etc/pkg/angie/angie-signing.rsa",
enabled: yes
}
```
3. Baixe a chave pública do repositório do Angie
para verificação de pacotes:
```console
$ sudo curl -o /usr/local/etc/pkg/angie/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Atualize os índices do repositório:
```console
$ sudo pkg update
```
5. Instale o pacote do Angie:
```console
$ sudo pkg install -r angie -y angie
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo pkg install -r angie -y
```
7. Inicie o serviço:
```console
$ sudo service angie start
```
8. Para inicializar automaticamente o Angie após a reinicialização do servidor:
```console
$ sudo sysrc angie_enable=YES
```
#### NOTE
Como o gerenciador de pacotes do FreeBSD pode determinar incorretamente a versão mais recente,
use a seguinte abordagem para atualizar pacotes já instalados:
```console
$ sudo pkg upgrade `pkg search -r angie angie-[0-9] | sort -Vr | head -1 | awk {'print $1'}`
```
### openSUSE
1. Para adicionar o repositório, crie um arquivo chamado
`/etc/zypp/repos.d/angie.repo`
com o seguinte conteúdo:
```ini
[angie]
name=Angie repo
baseurl=https://download.angie.software/angie/opensuse/$releasever_major/
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
2. Atualize os índices do repositório:
```console
$ sudo zypper refresh
```
3. Instale o pacote do Angie:
```console
$ sudo zypper install -y angie
```
4. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-oss)
que você precisar:
```console
$ sudo zypper install -y
```
5. Inicie o serviço:
```console
$ sudo systemctl start angie
```
6. Para inicializar automaticamente o Angie após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
## Extras
Além dos pacotes que fornecem a funcionalidade básica,
também publicamos alguns pacotes extras,
tanto nossos próprios quanto construídos a partir de fontes de terceiros selecionadas.
### Painel Web Console Light
Console Light é um painel web leve de monitoramento para o Angie,
publicado como `angie-console-light` em nossos repositórios.
É instalado da mesma forma que o pacote `angie` nos passos acima;
veja os passos de configuração em [Painel Web de Monitoramento Console Light](https://pt.angie.software//angie/docs/configuration/monitoring.md#monitoring).
### Módulos Dinâmicos
Para estender a funcionalidade básica do Angie,
você pode adicionar vários módulos dinâmicos.
Os módulos podem ser [construídos a partir do código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild)
contra uma versão correspondente do Angie,
mas é mais fácil obtê-los como pacotes prontos do nosso repositório:
| [angie-module-image-filter](https://pt.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) | Adiciona transformações para imagens JPEG, GIF, PNG e WebP. |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
| angie-module-njs: [JS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js) (HTTP), [JS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) (stream) | Permite usar njs (um subconjunto de JavaScript) na configuração do Angie nos contextos `http` e `stream`, respectivamente. |
| [angie-module-perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) | Permite escrever manipuladores de `location` e variáveis em Perl, e também invocar Perl a partir de SSI. |
| [angie-module-wamr](https://pt.angie.software//angie/docs/configuration/modules/wasm/wasm_wamr.md#wasm-wamr) | Permite integração com [WebAssembly Micro Runtime](https://github.com/bytecodealliance/wasm-micro-runtime) para executar código WASM. |
| [angie-module-wasm](https://pt.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-core) | Adiciona suporte básico a WASM. |
| [angie-module-wasmtime](https://pt.angie.software//angie/docs/configuration/modules/wasm/wasm_wasmtime.md#wasm-wasmtime) | Permite integração com o runtime [Wasmtime](https://wasmtime.dev/) para executar código WASM. |
| [angie-module-xslt](https://pt.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) | Adiciona um filtro para transformar respostas XML com folhas de estilo XSLT. |
Para usar um módulo instalado em uma [configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile),
carregue-o usando a diretiva [load_module](https://pt.angie.software//angie/docs/configuration/modules/core.md#load-module) no contexto `main`:
```nginx
load_module modules/.so;
```
Uma ampla gama de [módulos de terceiros](https://pt.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules)
também está disponível.
# https://pt.angie.software/angie/docs/installation/docker.md
# Imagens Docker do Angie
Para executar o Angie em um contêiner
[Docker](https://docs.docker.com/engine/reference/commandline/cli/),
use as imagens do nosso registro: `docker.angie.software`.
Elas são construídas baseadas em nossos [pacotes binários](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
e nas imagens base oficiais de vários sistemas operacionais.
#### NOTE
Essas imagens também podem ser executadas com motores de
contêineres compatíveis com Docker, como Podman.
A versão recomendada do Podman é 4.9.3 ou superior.
#### NOTE
Note também o módulo [Docker](https://pt.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker),
que implementa atualização dinâmica de grupos de servidores upstream
baseada em rótulos de contêineres Docker.
## Imagens Mínimas
- `angie:minimal`:
versão 1.12.1 baseada no Alpine 3.22.
- `angie:-minimal`:
versão especificada baseada no Alpine 3.22.
Essas imagens incluem apenas o pacote `angie`.
## Imagens com Templates
- `angie:templated`:
versão 1.12.1 baseada no Alpine 3.22.
- `angie:-templated`:
versão especificada baseada no Alpine 3.22.
Essas imagens definem as seguintes variáveis de ambiente:
```docker
ENV ANGIE_BINARY="angie"
ENV ANGIE_CONFIG_TEMPLATE="/etc/angie/angie.conf.t"
ENV ANGIE_ERROR_LOG_SEVERITY="notice"
ENV ANGIE_FEATURE_RELOAD="on"
ENV ANGIE_FEATURE_TEMPLATE="on"
ENV ANGIE_LOAD_MODULES=""
ENV ANGIE_PID_FILE="/run/angie/angie.pid"
ENV ANGIE_WORKER_CONNECTIONS="65536"
ENV ANGIE_WORKER_RLIMIT_NOFILE="65536"
```
Essas variáveis podem ser usadas para personalizar o comportamento do contêiner:
- `ANGIE_BINARY`:
Permite executar a [versão de debug](https://pt.angie.software//angie/docs/troubleshooting.md#debug-logging).
- `ANGIE_ERROR_LOG_SEVERITY`:
Define o nível de severidade para entradas no arquivo principal de [log de erro](https://pt.angie.software//angie/docs/configuration/processing.md#logging).
- `ANGIE_LOAD_MODULES`:
Carrega um ou mais módulos disponíveis (todos os módulos estão incluídos na imagem).
Especifique uma lista de módulos separados por vírgula sem espaços.
- `ANGIE_PID_FILE`:
Define um local alternativo para o arquivo de identificador de processo (PID).
- `ANGIE_FEATURE_TEMPLATE`:
Gera [configuração do Angie](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) usando a
ferramenta [gomplate](https://docs.gomplate.ca/) na inicialização do contêiner. Parâmetros
usados: `--input-dir /etc/angie/templates` e
`--output-dir /etc/angie`.
- `ANGIE_FEATURE_RELOAD`:
Habilita o tratamento dos sinais `SIGHUP`, `SIGQUIT` e `SIGTERM`.
Essas incluem os seguintes
[pacotes](https://pt.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules)
(se foram lançados para a [versão do Angie](https://pt.angie.software//angie/docs/oss_changes.md#oss-changes)
com a qual a imagem foi construída):
### Lista de Pacotes
- `angie-console-light`
- `angie-module-auth-jwt`
- `angie-module-auth-ldap`
- `angie-module-auth-pam`
- `angie-module-auth-spnego`
- `angie-module-auth-totp`
- `angie-module-brotli`
- `angie-module-cache-purge`
- `angie-module-cgi`
- `angie-module-combined-upstreams`
- `angie-module-dav-ext`
- `angie-module-dynamic-limit-req`
- `angie-module-echo`
- `angie-module-enhanced-memcached`
- `angie-module-eval`
- `angie-module-geoip2`
- `angie-module-headers-more`
- `angie-module-http-auth-radius`
- `angie-module-image-filter`
- `angie-module-keyval`
- `angie-module-lua`
- `angie-module-modsecurity`
- `angie-module-ndk`
- `angie-module-njs`
- `angie-module-opentracing`
- `angie-module-otel`
- `angie-module-perl`
- `angie-module-postgres`
- `angie-module-redis2`
- `angie-module-rtmp`
- `angie-module-set-misc`
- `angie-module-subs`
- `angie-module-testcookie`
- `angie-module-unbrotli`
- `angie-module-upload`
- `angie-module-vod`
- `angie-module-vts`
- `angie-module-wasm`
- `angie-module-wasmtime`
- `angie-module-xslt`
- `angie-module-zip`
- `angie-module-zstd`
### Exemplos
A configuração usada em imagens com templates aplica as variáveis
aproximadamente da seguinte forma:
```none
...
{{- if has $modules "zstd"}}
# package: angie-module-zstd
load_module modules/ngx_http_zstd_filter_module.so;
load_module modules/ngx_http_zstd_static_module.so;
{{end}}
user angie;
worker_processes auto;
worker_rlimit_nofile {{.Env.ANGIE_WORKER_RLIMIT_NOFILE}};
error_log /var/log/angie/error.log {{.Env.ANGIE_ERROR_LOG_SEVERITY}};
pid {{.Env.ANGIE_PID_FILE}};
events {
worker_connections {{.Env.ANGIE_WORKER_CONNECTIONS}};
}
http {
include /etc/angie/mime.types;
default_type application/octet-stream;
log_format main ...
```
Executando um contêiner com acesso ao shell:
```console
$ docker run -it --pull always --rm --entrypoint=sh \
docker.angie.software/angie:templated
```
Execute o Angie com parâmetros de conexão personalizados e módulos
(o comando **angie -T** irá exibir a configuração completa):
```console
$ docker run -it --rm -e ANGIE_WORKER_CONNECTIONS=4 \
-e ANGIE_LOAD_MODULES="auth-jwt,vod" \
docker.angie.software/angie:templated angie -T
```
Inicie um contêiner com um nome especificado e módulos adicionais:
```console
$ docker run -it --rm --name angie-test \
-e ANGIE_WORKER_CONNECTIONS=4 \
-e ANGIE_LOAD_MODULES="auth-jwt,vod" \
docker.angie.software/angie:templated
```
Recarregue a configuração de um contêiner em execução:
```console
$ docker kill -s HUP angie-test
```
## Imagens com Módulos Extras
- `angie:latest`:
versão 1.12.1 baseada no Alpine 3.22.
- `angie:`,
`angie:-alpine`:
versão especificada baseada no Alpine 3.22.
- `angie:-debian`:
versão especificada baseada no Debian 13.
- `angie:-rocky`:
versão especificada baseada no Rocky Linux 9.
- `angie:-ubuntu`:
versão especificada baseada no Ubuntu 24.04 LTS.
Essas incluem os seguintes
[pacotes](https://pt.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules)
(se foram lançados para a [versão do Angie](https://pt.angie.software//angie/docs/oss_changes.md#oss-changes)
com a qual a imagem foi construída):
### Lista de Pacotes
- `angie-console-light`
- `angie-module-auth-jwt`
- `angie-module-auth-ldap`
- `angie-module-auth-pam`
- `angie-module-auth-spnego`
- `angie-module-auth-totp`
- `angie-module-brotli`
- `angie-module-cache-purge`
- `angie-module-cgi`
- `angie-module-combined-upstreams`
- `angie-module-dav-ext`
- `angie-module-dynamic-limit-req`
- `angie-module-echo`
- `angie-module-enhanced-memcached`
- `angie-module-eval`
- `angie-module-geoip2`
- `angie-module-headers-more`
- `angie-module-http-auth-radius`
- `angie-module-image-filter`
- `angie-module-keyval`
- `angie-module-lua`
- `angie-module-modsecurity`
- `angie-module-ndk`
- `angie-module-njs`
- `angie-module-opentracing`
- `angie-module-otel`
- `angie-module-perl`
- `angie-module-postgres`
- `angie-module-redis2`
- `angie-module-rtmp`
- `angie-module-set-misc`
- `angie-module-subs`
- `angie-module-testcookie`
- `angie-module-unbrotli`
- `angie-module-upload`
- `angie-module-vod`
- `angie-module-vts`
- `angie-module-wasm`
- `angie-module-wasmtime`
- `angie-module-xslt`
- `angie-module-zip`
- `angie-module-zstd`
## Execução
Para iniciar um contêiner com Angie na porta 8080,
fornecendo acesso somente leitura ao diretório de arquivos estáticos `/var/www/`
e ao arquivo de configuração `angie.conf` localizado no diretório de trabalho atual:
```console
$ docker run --rm --name angie -v /var/www:/usr/share/angie/html:ro \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d docker.angie.software/angie:latest
$ curl -I localhost:8080
HTTP/1.1 200 OK
Server: Angie/1.12.1
Date: Fri, 17 Jul 2026 10:42:54 GMT
Content-Type: text/html
Content-Length: 543
Last-Modified: Fri, 17 Jul 2026 09:12:23 GMT
Connection: keep-alive
ETag: "64c3ccc7-21f"
Accept-Ranges: bytes
```
Tais configurações são adequadas para desenvolvimento local e configuração.
Ao usar o [módulo ACME](https://pt.angie.software//angie/docs/configuration/acme.md#acme-config) para obter certificados, monte o
diretório de armazenamento de certificados em um volume persistente para que os
certificados emitidos sobrevivam à recriação do contêiner. Caso contrário, cada
contêiner recriado inicia com o armazenamento vazio e solicita novos
certificados, o que pode atingir os [limites de taxa](https://letsencrypt.org/docs/rate-limits/) da CA:
```console
$ docker run --rm --name angie -v angie-acme:/var/lib/angie/acme \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 80:80 -p 443:443 -d docker.angie.software/angie:latest
```
## Construindo Imagens Personalizadas
Você também pode construir sua própria imagem
baseada em uma distribuição suportada,
adicionando a camada do Angie a partir de [pacotes](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
ou [código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild).
Exemplos de arquivos `Dockerfile` correspondentes:
```dockerfile
FROM debian:13
LABEL org.opencontainers.image.authors="Release Engineering Team "
ARG DEBIAN_FRONTEND=noninteractive
RUN set -x \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
ca-certificates curl \
&& curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg \
&& echo "deb https://download.angie.software/angie/$(. /etc/os-release && echo "$ID/$VERSION_ID $VERSION_CODENAME") main" \
> /etc/apt/sources.list.d/angie.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
angie angie-module-geoip2 angie-module-njs \
&& rm -Rf /var/lib/apt/lists \
/etc/apt/sources.list.d/angie.list \
/etc/apt/trusted.gpg.d/angie-signing.gpg \
&& ln -sf /dev/stdout /var/log/angie/access.log \
&& ln -sf /dev/stderr /var/log/angie/error.log
EXPOSE 80
CMD ["angie", "-g", "daemon off;"]
```
```dockerfile
FROM alpine:3.22
LABEL org.opencontainers.image.authors="Release Engineering Team "
RUN set -x \
&& apk add --no-cache ca-certificates curl \
&& curl -o /etc/apk/keys/angie-signing.rsa https://angie.software/keys/angie-signing.rsa \
&& echo "https://download.angie.software/angie/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" >> /etc/apk/repositories \
&& apk add --no-cache angie angie-module-geoip2 angie-module-njs \
&& rm /etc/apk/keys/angie-signing.rsa \
&& ln -sf /dev/stdout /var/log/angie/access.log \
&& ln -sf /dev/stderr /var/log/angie/error.log
EXPOSE 80
CMD ["angie", "-g", "daemon off;"]
```
Para construir uma imagem `myangie` no diretório com tal `Dockerfile`
e iniciar um contêiner como mostrado acima:
```console
$ docker build -t myangie .
$ docker run --rm --name myangie -v /var/www:/usr/share/angie/html:ro \
-v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d myangie
```
# https://pt.angie.software/angie/docs/installation/sourcebuild.md
# Compilando o Angie a partir do Código-fonte
Recomendamos instalar o Angie a partir dos
[pacotes](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages) oficiais pré-compilados.
No entanto, se você ainda precisar de sua própria compilação, certifique-se de
que os pré-requisitos estejam em vigor primeiro.
#### NOTE
A compilação do Angie requer um compilador C (**gcc** ou
**clang**) e o **make**, além das bibliotecas PCRE2,
zlib e OpenSSL. Instale os pacotes de desenvolvimento fornecidos
pela sua distribuição. No Debian e Ubuntu:
```console
$ sudo apt install build-essential libpcre2-dev zlib1g-dev libssl-dev
```
No RHEL, Fedora e derivados:
```console
$ sudo dnf install gcc make pcre2-devel zlib-devel openssl-devel
```
Como alternativa, compile essas bibliotecas estaticamente junto com o Angie
usando as opções `--with-pcre=`, `--with-zlib=` e
`--with-openssl=` mostradas nos [Exemplos](#examples-2).
Para compilar o Angie a partir do código-fonte:
1. Baixe o arquivo `.tar.gz` do
[nosso site](https://download.angie.software/files/):
```console
$ curl -O https://download.angie.software/files/angie-1.12.1.tar.gz
```
2. Descompacte o arquivo e navegue até o diretório do código-fonte:
```console
$ tar -xpf angie-1.12.1.tar.gz
$ cd angie-1.12.1
```
3. Para preparar a compilação, use o script **./configure**,
que determina as características específicas do SO onde a compilação ocorre,
particularmente os métodos que o Angie pode usar para lidar com conexões.
Após uma execução bem-sucedida, o script cria um `Makefile`.
Com os pré-requisitos instalados, uma compilação mínima não precisa de opções:
```console
$ ./configure
```
Caso contrário, revise e defina as [opções de compilação](#configure)
necessárias para os módulos e bibliotecas de que você precisa (consulte os
[Exemplos](#examples-2)):
```console
$ ./configure
```
4. Quando o `Makefile` estiver pronto, compile e instale o Angie:
```console
$ make
$ make install
```
## Opções de Compilação
### Geral
| Opção | Descrição | Padrão |
|------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
| `--help` | Imprime uma mensagem de ajuda. | |
| `--user=`name | Define o nome de um usuário sem privilégios cujas credenciais serão usadas pelos processos worker. Após a instalação, o nome sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [user](https://pt.angie.software//angie/docs/configuration/modules/core.md#user). | `nobody` |
| `--group=`name | Define o nome de um grupo cujas credenciais serão usadas pelos processos worker. Após a instalação, o nome sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [user](https://pt.angie.software//angie/docs/configuration/modules/core.md#user). | configuração de `--user` |
| `--build=`name | Define um nome opcional para a compilação. | |
| `--builddir=`path | Define o diretório de compilação. | `objs` |
| `--feature-cache=`path | Especifica o diretório para cache de artefatos de compilação. | Se definido sem um caminho, a configuração de `--builddir` é usada |
### Caminhos
| Opção | Descrição | Padrão |
|-------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------|
| `--prefix=`path | Define o diretório que armazenará os arquivos do servidor. Este mesmo diretório também será usado para todos os caminhos relativos definidos por **./configure** (exceto para caminhos para fontes de biblioteca) e no arquivo de configuração `angie.conf`. | `/usr/local/angie` |
| `--sbin-path=`path | Define o nome do executável do Angie. Este nome é usado apenas durante a instalação. | `/sbin/angie` |
| `--modules-path=`path | Define o diretório onde os módulos dinâmicos serão instalados. | `/modules` |
| `--conf-path=`path | Define o nome do [arquivo de configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) `angie.conf`. Se necessário, você sempre pode iniciar o Angie com um arquivo de configuração diferente usando a [opção de linha de comando](https://pt.angie.software//angie/docs/configuration/runtime.md#runtime-cli-options) `-c`. | `/conf/angie.conf` |
| `--error-log-path=`path | Define o nome do arquivo de log principal de erro, aviso e diagnóstico. Após a instalação, o nome do arquivo sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log). | `/logs/error.log` |
| `--pid-path=`path | Define o nome do arquivo `angie.pid` que armazenará o ID do processo do processo principal. Após a instalação, o nome do arquivo sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [pid](https://pt.angie.software//angie/docs/configuration/modules/core.md#pid). | `/logs/angie.pid` |
| `--lock-path=`path | Define o prefixo para nomes de arquivos de bloqueio. Após a instalação, o valor sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [lock_file](https://pt.angie.software//angie/docs/configuration/modules/core.md#lock-file). | `/logs/angie.lock` |
| `--http-acme-client-path=`path | Define o diretório para armazenar certificados e chaves para blocos `server` que têm diretivas [acme](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#id1) definidas. | `/acme_client` |
| `--http-log-path=`path | Define o nome do arquivo de log de requisições principal para o servidor HTTP. Após a instalação, o nome do arquivo sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [access_log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log). | `/logs/access.log` |
| `--http-client-body-temp-path=`path | Define o diretório para armazenar arquivos temporários que contêm corpos de requisições de clientes. Após a instalação, o diretório sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [client_body_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#client-body-temp-path). | `/client_body_temp` |
| `--http-proxy-temp-path=`path | Define o diretório para armazenar arquivos temporários com dados recebidos de servidores proxy. Após a instalação, o diretório sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [proxy_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-temp-path). | `/proxy_temp` |
| `--http-fastcgi-temp-path=`path | Define o diretório para armazenar arquivos temporários com dados recebidos de servidores FastCGI. Após a instalação, o diretório sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [fastcgi_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-temp-path). | `/fastcgi_temp` |
| `--http-uwsgi-temp-path=`path | Define o diretório para armazenar arquivos temporários com dados recebidos de servidores uWSGI. Após a instalação, o diretório sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [uwsgi_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-temp-path). | `/uwsgi_temp` |
| `--http-scgi-temp-path=`path | Define o diretório para armazenar arquivos temporários com dados recebidos de servidores SCGI. Após a instalação, o diretório sempre pode ser alterado no arquivo de configuração `angie.conf` usando a diretiva [scgi_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-temp-path). | `/scgi_temp` |
### Recursos e dependências
| `--with-select_module`, `--without-select_module` | Habilita ou desabilita a construção de um módulo que permite ao servidor trabalhar com o método `select()`. Este módulo é construído automaticamente se a plataforma não parecer suportar métodos mais apropriados como `kqueue`, `epoll`, ou `/dev/poll`. |
|-----------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-poll_module`, `--without-poll_module` | Habilita ou desabilita a construção de um módulo que permite ao servidor trabalhar com o método `poll()`. Este módulo é construído automaticamente se a plataforma não parecer suportar métodos mais apropriados como `kqueue`, `epoll`, ou `/dev/poll`. |
| `--with-threads` | Habilita o uso de [pools de threads](https://pt.angie.software//angie/docs/configuration/modules/core.md#thread-pool) (modo `aio threads`). |
| `--with-file-aio` | Habilita o uso de [I/O de arquivo assíncrono](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#aio) (AIO) no FreeBSD e Linux (modo `aio on`). |
| `--with-debug` | Habilita o [log de depuração](https://pt.angie.software//angie/docs/troubleshooting.md#debug-logging). |
| `--without-http-cache` | Desabilita o cache HTTP. |
| `--with-pcre`, `--with-pcre=`path | Habilita o uso da biblioteca PCRE.
O parâmetro opcional define o caminho para os fontes da biblioteca PCRE. A distribuição da biblioteca precisa ser baixada do site [PCRE](http://www.pcre.org/) e extraída. O resto é feito pelos comandos **./configure** e **make** do Angie.
A biblioteca é **obrigatória** para suporte a expressões regulares na diretiva `location` e para o módulo [Rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite). |
| `--with-pcre-opt=`parameters | Define parâmetros adicionais de construção para PCRE. |
| `--with-pcre-jit` | Constrói a biblioteca PCRE com suporte à compilação JIT (a diretiva [pcre_jit](https://pt.angie.software//angie/docs/configuration/modules/core.md#pcre-jit)). |
| `--without-pcre` | Desabilita o uso da biblioteca PCRE. |
| `--without-pcre2` | Desabilita o uso da biblioteca PCRE2 em vez da biblioteca PCRE original. |
| `--with-libatomic`, `--with-libatomic=`path | Habilita a construção com a biblioteca **libatomic_ops**. O parâmetro opcional define o caminho para os fontes da biblioteca. |
| `--with-openssl=`path | Habilita construção estática e define o caminho para os fontes da biblioteca OpenSSL. AWS-LC pode ser usado como uma biblioteca compatível com OpenSSL. |
| `--with-openssl-opt=`parameters | Define parâmetros adicionais de construção para OpenSSL. |
| `--with-ntls` | Habilita suporte NTLS no módulo HTTP ([lado servidor](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-ntls), [lado cliente](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-ntls)) e módulo stream ([lado servidor](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-ntls), [lado cliente](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-ssl-ntls)) ao construir com uma biblioteca SSL que suporta NTLS. |
| `--with-zlib=`path | Define o caminho para os fontes da biblioteca zlib. A distribuição da biblioteca (versão 1.1.3 ou posterior) precisa ser baixada do [site zlib](https://zlib.net/) e extraída; versões mais antigas que a atual estão arquivadas em [zlib fossils](https://zlib.net/fossils/). O resto é feito pelos comandos **./configure** e **make** do Angie.
A biblioteca é **obrigatória** para o módulo [GZip](https://pt.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip). |
| `--with-zlib-opt=`parameters | Define parâmetros adicionais de construção para zlib. |
| `--with-zlib-asm=`cpu | Habilita o uso de otimizações assembly para construir zlib, otimizado para um dos seguintes processadores: `pentium`, `pentiumpro`. |
### Habilitando e Desabilitando Módulos
Você pode desabilitar módulos que estão habilitados por padrão, ou habilitar módulos
que estão disponíveis mas desabilitados por padrão.
#### HTTP
Habilitando módulos adicionais:
| `--with-http_acme_module` | Habilita a construção do módulo [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme), que habilita o protocolo ACME. |
|----------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-http_addition_module` | Habilita a construção do módulo [Addition](https://pt.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition) que permite adicionar texto antes e depois de uma resposta. |
| `--with-http_auth_request_module` | Habilita a construção do módulo [Auth Request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) que fornece capacidade de autorização de cliente baseada no resultado de uma subrequisição. |
| `--with-http_dav_module` | Habilita a construção do módulo [DAV](https://pt.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) destinado a automatizar tarefas de gerenciamento de arquivos no servidor via protocolo WebDAV. |
| `--with-http_degradation_module` | Habilita a construção do módulo Degradation que permite retornar códigos de status HTTP 204 ou 444 para certos blocos `location`.
Este módulo só pode ser usado em casos onde `sbrk(0)` mostra a quantidade real de memória alocada para o processo. Em outras palavras, o módulo funciona no FreeBSD até a versão 7.0 por padrão. A partir da versão 7.0, funciona apenas se `MALLOC_OPTIONS=Dm` estiver definido. No Linux não funciona. |
| `--with-http_flv_module` | Habilita a construção do módulo [FLV](https://pt.angie.software//angie/docs/configuration/modules/http/http_flv.md#http-flv) que fornece suporte de pseudo-streaming do lado do servidor para arquivos Flash Video (FLV). |
| `--with-http_geoip_module`, `--with-http_geoip_module=dynamic` | Habilita a construção do módulo [GeoIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_geoip.md#http-geoip) que cria variáveis cujos valores são determinados baseados no endereço IP do cliente e bancos de dados prontos da [MaxMind](http://www.maxmind.com/). |
| `--with-http_gunzip_module` | Habilita a construção do módulo [GunZIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_gunzip.md#http-gunzip) que permite descomprimir respostas com `Content-Encoding: gzip` para clientes que não suportam o método de compressão `gzip`. |
| `--with-http_gzip_static_module` | Habilita a construção do módulo [Gzip Static](https://pt.angie.software//angie/docs/configuration/modules/http/http_gzip_static.md#http-gzip-static) que permite servir um arquivo pré-comprimido com o mesmo nome e a extensão `.gz` em vez de um arquivo regular. |
| `--with-http_image_filter_module`, `--with-http_image_filter_module=dynamic` | Habilita a construção do módulo [Image Filter](https://pt.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) que permite transformar imagens nos formatos JPEG, GIF, PNG e WebP. |
| `--with-http_mp4_module` | Habilita a construção do módulo [MP4](https://pt.angie.software//angie/docs/configuration/modules/http/http_mp4.md#http-mp4) que fornece suporte de pseudo-streaming do lado do servidor para arquivos no formato MP4. |
| `--with-http_perl_module`, `--with-http_perl_module=dynamic` | Habilita a construção do módulo [Perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl). |
| `--with-perl_modules_path=`path | Define o diretório onde os arquivos de módulo Perl estarão localizados. |
| `--with-perl=`path | Define o nome do arquivo executável Perl. |
| `--with-http_random_index_module` | Habilita a construção do módulo [Random Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) que atende requisições terminadas com uma barra (`/`) e retorna um arquivo aleatório como arquivo de índice do diretório. |
| `--with-http_realip_module` | Habilita a construção do módulo [RealIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip) que permite alterar o endereço do cliente para aquele passado no campo de cabeçalho especificado. |
| `--with-http_secure_link_module` | Habilita a construção do módulo [Secure Link](https://pt.angie.software//angie/docs/configuration/modules/http/http_secure_link.md#http-secure-link). |
| `--with-http_slice_module` | Habilita a construção do módulo [Slice](https://pt.angie.software//angie/docs/configuration/modules/http/http_slice.md#http-slice) que permite dividir uma requisição em subrequisições, cada uma retornando um intervalo específico da resposta. O módulo fornece cache eficiente de respostas grandes. |
| `--with-http_ssl_module` | Habilita suporte [SSL](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#http-ssl) para o servidor HTTP.
A biblioteca OpenSSL é **obrigatória** para este módulo. |
| `--with-http_stub_status_module` | Habilita a construção do módulo [Stub Status](https://pt.angie.software//angie/docs/configuration/modules/http/http_stub_status.md#http-stub-status) que fornece acesso a informações básicas de status do servidor. |
| `--with-http_sub_module` | Habilita a construção do módulo [Sub](https://pt.angie.software//angie/docs/configuration/modules/http/http_sub.md#http-sub) que permite modificar uma string especificada na resposta para outra. |
| `--with-http_v2_module` | Habilita o módulo [HTTP/2](https://pt.angie.software//angie/docs/configuration/modules/http/http_v2.md#http-v2). |
| `--with-http_v3_module` | Habilita o módulo [HTTP/3](https://pt.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3). |
#### NOTE
Para construção, é **fortemente recomendado** usar uma biblioteca SSL
que suporte o protocolo [QUIC](https://www.rfc-editor.org/rfc/rfc9000.html):
BoringSSL
Construindo com [BoringSSL](https://boringssl.googlesource.com/boringssl):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../boringssl/include" \
--with-ld-opt="-L../boringssl/build/ssl -L../boringssl/build/crypto"
```
LibreSSL
Construindo com [LibreSSL](https://www.libressl.org/):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../libressl/build/include" \
--with-ld-opt="-L../libressl/build/lib"
```
QuicTLS
Construindo com [QuicTLS](https://github.com/quictls/openssl):
```console
$ ./configure \
--with-debug \
--with-http_v3_module \
--with-cc-opt="-I../quictls/build/include" \
--with-ld-opt="-L../quictls/build/lib"
```
Sem isso, a biblioteca [OpenSSL](https://openssl.org/) será usada em modo de compatibilidade, onde
o envio de [early data](https://datatracker.ietf.org/doc/html/rfc8446#section-2.3) não é
suportado e outros recursos estão ausentes, como reutilização de sessão. Tal
construção será capaz de interagir **apenas** com clientes e servidores
usando OpenSSL no mesmo modo.
Esse fallback é silencioso: se a biblioteca SSL configurada estiver ausente
ou inutilizável, o **./configure** usa o OpenSSL do sistema em vez de
relatar um erro. Após a conclusão, verifique o `Configuration
summary`: uma linha com `+ using system OpenSSL library` significa que
a biblioteca compatível com QUIC pretendida não foi utilizada.
| `--with-http_xslt_module`, `--with-http_xslt_module=dynamic` | Habilita a construção do módulo [XSLT](https://pt.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) que permite transformar respostas XML usando folhas de estilo XSLT.
As bibliotecas **libxml2** e **libxslt** são **obrigatórias** para este módulo. |
|----------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-google_perftools_module` | Habilita a construção do módulo [Google PerfTools](https://pt.angie.software//angie/docs/configuration/modules/google_perftools.md#google-perftools) que fornece suporte para criação de perfil de processos worker do Angie usando [Google Performance Tools](https://github.com/gperftools/gperftools). O módulo é destinado aos desenvolvedores do Angie. |
Desabilitando módulos padrão:
| `--without-http` | Desabilita o servidor [HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#http-core). |
|---------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-http_access_module` | Desabilita a construção do módulo [Access](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) que permite limitar o acesso a determinados endereços de cliente. |
| `--without-http_api_module` | Desabilita a construção do módulo [API](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#http-api) que fornece uma interface HTTP RESTful para acessar informações baseadas em JSON sobre a instância do servidor web. |
| `--without-http_metric_module` | Desabilita a construção do módulo [Metric](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric). |
| `--without-http_auth_basic_module` | Desabilita a construção do módulo [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) que permite limitar o acesso a recursos validando o nome de usuário e senha usando o protocolo HTTP Basic Authentication. |
| `--without-http_autoindex_module` | Desabilita a construção do módulo [AutoIndex](https://pt.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex) que processa solicitações terminadas com o caractere de barra (`/`) e produz uma listagem de diretório caso o módulo [Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) não consiga encontrar um arquivo de índice. |
| `--without-http_browser_module` | Desabilita a construção do módulo [Browser](https://pt.angie.software//angie/docs/configuration/modules/http/http_browser.md#http-browser) que cria variáveis cujos valores dependem do valor do campo de cabeçalho de solicitação `User-Agent`. |
| `--without-http_charset_module` | Desabilita a construção do módulo [Charset](https://pt.angie.software//angie/docs/configuration/modules/http/http_charset.md#http-charset) que adiciona o charset especificado ao campo de cabeçalho de resposta `Content-Type` e pode adicionalmente converter dados de um charset para outro. |
| `--without-http_empty_gif_module` | Desabilita a construção do [módulo](https://pt.angie.software//angie/docs/configuration/modules/http/http_empty_gif.md#http-empty-gif) que emite um GIF transparente de um único pixel. |
| `--without-http_fastcgi_module` | Desabilita a construção do módulo [FastCGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#http-fastcgi) que passa solicitações para um servidor FastCGI. |
| `--without-http_geo_module` | Desabilita a construção do módulo [Geo](https://pt.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo) que cria variáveis com valores dependendo do endereço IP do cliente. |
| `--without-http_gzip_module` | Desabilita a construção do [módulo](https://pt.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip) que comprime as respostas do servidor HTTP.
A biblioteca zlib é **obrigatória** para este módulo. |
| `--without-http_grpc_module` | Desabilita a construção do módulo [gRPC](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#http-grpc) que passa solicitações para um servidor gRPC. |
| `--without-http_limit_conn_module` | Desabilita a construção do módulo [Limit Conn](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn) que limita o número de conexões por chave, por exemplo, o número de conexões de um único endereço IP. |
| `--without-http_limit_req_module` | Desabilita a construção do módulo [Limit Req](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) que limita a taxa de processamento de solicitações por chave, por exemplo, a taxa de processamento de solicitações vindas de um único endereço IP. |
| `--without-http_map_module` | Desabilita a construção do módulo [Map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#http-map) que cria variáveis com valores dependendo dos valores de outras variáveis. |
| `--without-http_memcached_module` | Desabilita a construção do módulo [Memcached](https://pt.angie.software//angie/docs/configuration/modules/http/http_memcached.md#http-memcached) que obtém respostas de um servidor memcached. |
| `--without-http_mirror_module` | Desabilita a construção do módulo [Mirror](https://pt.angie.software//angie/docs/configuration/modules/http/http_mirror.md#http-mirror) que implementa o espelhamento de uma solicitação original criando sub-solicitações de espelho em segundo plano. |
| `--without-http_prometheus_module` | Desabilita a construção do módulo [Prometheus](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus) para o servidor HTTP. |
| `--without-http_proxy_module` | Desabilita a construção do módulo [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) para o servidor HTTP. |
| `--without-http_referer_module` | Desabilita a construção do módulo [Referer](https://pt.angie.software//angie/docs/configuration/modules/http/http_referer.md#http-referer) que pode bloquear o acesso a um site para solicitações com valores inválidos no campo de cabeçalho `Referer`. |
| `--without-http_rewrite_module` | Desabilita a construção do módulo [Rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite) que permite ao servidor HTTP redirecionar solicitações e alterar seus URIs.
A biblioteca PCRE é **obrigatória** para este módulo. |
| `--without-http_scgi_module` | Desabilita a construção do módulo [SCGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#http-scgi) que passa solicitações para um servidor SCGI. |
| `--without-http_split_clients_module` | Desabilita a construção do módulo [Split Clients](https://pt.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#http-split-clients) que cria variáveis para testes A/B. |
| `--without-http_ssi_module` | Desabilita a construção do módulo [SSI](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi) que processa comandos SSI (Server Side Includes) em respostas que passam por ele. |
| `--without-http_upstream_hash_module` | Desabilita a construção do módulo que implementa o método de balanceamento de carga [hash](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-hash). |
| `--without-http_upstream_ip_hash_module` | Desabilita a construção do módulo que implementa o método de balanceamento de carga [ip_hash](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-ip-hash). |
| `--without-http_upstream_keepalive_module` | Desabilita a construção do módulo que fornece [cache de conexão](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-keepalive) para servidores upstream. |
| `--without-http_upstream_least_conn_module` | Desabilita a construção do módulo que implementa o método de balanceamento de carga [least_conn](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-conn). |
| `--without-http_upstream_random_module` | Desabilita a construção do módulo que implementa o método de balanceamento de carga [random](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-random). |
| `--without-http_upstream_sticky_module` | Desabilita a construção do módulo que implementa [persistência de sessão](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky), garantindo que todas as solicitações na sessão do cliente sejam passadas para o mesmo servidor no upstream. |
| `--without-http_upstream_zone_module` | Desabilita a construção do módulo que permite armazenar o estado de tempo de execução de um upstream em uma [zona de memória compartilhada](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone). |
| `--without-http_userid_module` | Desabilita a construção do módulo [UserID](https://pt.angie.software//angie/docs/configuration/modules/http/http_userid.md#http-userid) que define cookies adequados para identificação do cliente. |
| `--without-http_uwsgi_module` | Desabilita a construção do módulo [uWSGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#http-uwsgi) que passa solicitações para um servidor uWSGI. |
#### Módulos Stream
Habilitando módulos adicionais:
#### \* - `--with-stream`, `--with-stream=dynamic` - Habilita o módulo principal [Stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) para proxy TCP/UDP genérico e balanceamento de carga.
| `--with-stream_acme_module` | Habilita a construção do módulo [ACME](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme), que habilita o protocolo ACME. |
|--------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--with-stream_geoip_module`, `--with-stream_geoip_module=dynamic` | Habilita o módulo [GeoIP](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_geoip.md#stream-geoip) que cria variáveis dependendo do endereço IP do cliente e dos bancos de dados pré-compilados [MaxMind](http://www.maxmind.com/). |
| `--with-stream_mqtt_preread_module` | Habilita o módulo [MQTT Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#stream-mqtt-preread) que permite extrair IDs de cliente e nomes de usuário de pacotes `CONNECT` nas versões MQTT [3.1.1](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718028) e [5.0](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901033). |
| `--with-stream_rdp_preread_module` | Habilita o módulo [RDP Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#stream-rdp-preread) que permite extrair cookies de sessões RDP. |
| `--with-stream_realip_module` | Habilita o módulo [RealIP](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip) que altera o endereço do cliente para o endereço enviado no cabeçalho do protocolo PROXY. |
| `--with-stream_ssl_module` | Habilita o suporte [SSL](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) para o servidor Stream.
A biblioteca OpenSSL é **obrigatória** para construir e executar este módulo. |
| `--with-stream_ssl_preread_module` | Habilita o módulo [SSL Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) que permite extrair informações de mensagens [ClientHello](https://datatracker.ietf.org/doc/html/rfc5246#section-7.4.1.2) sem terminar SSL/TLS. |
| `--with-stream_upstream_probe_icmp` (PRO) | Habilita sondas de eco ICMP para a diretiva [upstream_probe (PRO)](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe). Requer suporte ICMP do sistema operacional. |
Desabilitando módulos padrão:
#### \* - `--without-stream_access_module` - Desabilita o módulo [Access](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) que permite limitar o acesso a determinados endereços de cliente.
| `--without-stream_geo_module` | Desabilita o módulo [Geo](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_geo.md#stream-geo) que cria variáveis com valores dependendo do endereço IP do cliente. |
|-----------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-stream_limit_conn_module` | Desabilita o módulo [Limit Conn](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn) que limita o número de conexões por chave, por exemplo, o número de conexões de um único endereço IP. |
| `--without-stream_map_module` | Desabilita o módulo [Map](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_map.md#stream-map) que cria variáveis com valores dependendo de valores de outras variáveis. |
| `--without-stream_return_module` | Desabilita o módulo [Return](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) que envia o valor especificado para o cliente e então fecha a conexão. |
| `--without-stream_set_module` | Desabilita o módulo [Set](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) que define um valor para uma variável. |
| `--without-stream_split_clients_module` | Desabilita o módulo [Split Clients](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_split_clients.md#stream-split-clients) que cria variáveis para testes A/B. |
| `--without-stream_upstream_hash_module` | Desabilita o módulo que implementa o método de balanceamento de carga [hash](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-hash). |
| `--without-stream_upstream_least_conn_module` | Desabilita o módulo que implementa o método de balanceamento de carga [least_conn](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-least-conn). |
| `--without-stream_upstream_random_module` | Desabilita o módulo que implementa o método de balanceamento de carga [random](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-random). |
| `--without-stream_upstream_zone_module` | Desabilita o módulo que permite armazenar o estado de tempo de execução de um upstream em uma [zona de memória compartilhada](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone). |
#### Mail
Habilitando módulos adicionais:
#### \* - `--with-mail`, `--with-mail=dynamic` - Habilita o módulo principal [Mail](https://pt.angie.software//angie/docs/configuration/modules/mail/index.md#mail-core) que suporta POP3, IMAP4 e SMTP.
| `--with-mail_ssl_module` | Habilita o suporte [SSL](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#mail-ssl) para o servidor Mail.
A biblioteca OpenSSL é **obrigatória** para construir e executar este módulo. |
|----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
Desabilitando módulos padrão:
#### \* - `--without-mail_imap_module` - Desabilita o protocolo [IMAP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_imap.md#mail-imap) no servidor Mail.
| `--without-mail_pop3_module` | Desabilita o protocolo [POP3](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_pop3.md#mail-pop3) no servidor Mail. |
|--------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------|
| `--without-mail_smtp_module` | Desabilita o protocolo [SMTP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#mail-smtp) no servidor Mail. |
#### Outras opções
#### \* - `--with-cpp_test_module` - Habilita o módulo CPP Test. É usado principalmente para desenvolvimento e propósitos de teste e não é destinado para uso em produção.
| `--add-module=`path | Habilita a construção de um módulo externo no caminho especificado. |
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--add-dynamic-module=`path | Habilita a construção de um módulo dinâmico externo no caminho especificado. |
| `--with-compat` | Habilita o modo de compatibilidade de módulo dinâmico. Quando habilitado, o Angie pode carregar e usar módulos dinâmicos que foram construídos para a mesma versão do Angie, mesmo se esses módulos foram construídos com opções diferentes. O Angie PRO pode carregar apenas módulos construídos para o Angie PRO; módulos do Angie (OSS) são rejeitados devido a uma assinatura de módulo diferente. |
| `--with-cc=`path | Define o compilador a ser usado durante a construção. |
| `--with-cpp=`path | Define o pré-processador a ser usado durante a construção. |
| `--with-cc-opt=`parameters | Define parâmetros adicionais que serão adicionados à variável `CFLAGS`. Ao usar a biblioteca PCRE do sistema no FreeBSD, `--with-cc-opt="-I /usr/local/include"` deve ser especificado. Se o número de arquivos suportados por `select()` precisa ser aumentado, também pode ser especificado aqui, como `--with-cc-opt="-D FD_SETSIZE=2048"`. |
| `--with-ld-opt=`parameters | Define parâmetros adicionais que serão usados durante a vinculação. Ao usar a biblioteca PCRE do sistema no FreeBSD, `--with-ld-opt="-L /usr/local/lib"` deve ser especificado. |
| `--with-cpu-opt=`cpu | Habilita construções otimizadas para um dos seguintes processadores: `pentium`, `pentiumpro`, `pentium3`, `pentium4`, `athlon`, `opteron`, `sparc32`, `sparc64`, `ppc64`. |
### Exemplos
**Construção Simples com HTTPS Habilitado**. Esta configuração básica habilita o suporte HTTPS
usando SSL/TLS, com as dependências necessárias (PCRE para expressões regulares,
zlib para compressão e OpenSSL para SSL/TLS):
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-http_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-zlib=../zlib-1.3 \
--with-openssl=../openssl-3.0.8
```
**Construção Otimizada para Desempenho**. Esta configuração é otimizada para desempenho,
incluindo suporte HTTP/2, compressão estática **gzip**, JIT para PCRE e
I/O assíncrono; pools de threads também são habilitados para manuseio eficiente de altas
cargas:
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-http_ssl_module \
--with-http_v2_module \
--with-http_gzip_static_module \
--with-pcre=../pcre2-10.40 \
--with-pcre-jit \
--with-zlib=../zlib-1.3 \
--with-threads \
--with-file-aio
```
**Balanceador de Carga com Proxy TCP/UDP**. Esta configuração configura um
balanceador de carga para serviços HTTP e não-HTTP:
```console
$ ./configure \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--with-stream \
--with-stream_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-zlib=../zlib-1.3
```
**Construção Especializada**. Esta configuração inclui HTTPS, HTTP/2, compressão,
segurança e desempenho aprimorados, juntamente com módulos adicionais para
compressão Brotli e gerenciamento de cache, otimizada tanto para proxy HTTP
quanto TCP/UDP:
```console
$ ./configure \
--prefix=/usr/local/angie \
--sbin-path=/usr/sbin/angie \
--conf-path=/etc/angie/angie.conf \
--pid-path=/run/angie.pid \
--lock-path=/var/lock/angie.lock \
--error-log-path=/var/log/angie/error.log \
--http-log-path=/var/log/angie/access.log \
--with-http_ssl_module \
--with-http_v2_module \
--with-http_realip_module \
--with-http_gzip_static_module \
--with-http_stub_status_module \
--with-threads \
--with-file-aio \
--with-stream \
--with-stream_ssl_module \
--with-pcre=../pcre2-10.40 \
--with-pcre-jit \
--with-zlib=../zlib-1.3 \
--with-openssl=../openssl-3.0.8 \
--with-openssl-opt="enable-ec_nistp_64_gcc_128" \
--add-module=../ngx_brotli \
--add-dynamic-module=../ngx_cache_purge
```
As opções `--add-module` e `--add-dynamic-module` acima
referenciam fontes de módulos de terceiros que você baixa separadamente. Por
exemplo, clone-os ao lado da árvore de código-fonte do Angie:
```console
$ git clone --recurse-submodules https://github.com/google/ngx_brotli
$ git clone https://github.com/nginx-modules/ngx_cache_purge
```
Consulte [Módulos de Terceiros](https://pt.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules) para os módulos
que o Angie empacota e suas fontes.
# https://pt.angie.software/angie/docs/installation/pro_packages.md
# Instalação por Pacotes do Angie PRO
Para acessar o repositório de pacotes,
você precisa assinar um contrato e adquirir uma licença.
Para questões sobre licenças, contratos e builds personalizados, entre em contato:
- [info@wbsrv.ru](mailto:info@wbsrv.ru)
- [https://angie.software/](https://angie.software/)
- +7 (495) 120 50 33
Em seguida, configure o repositório para o gerenciador de pacotes da sua distribuição
para instalar e atualizar o Angie PRO
e os [módulos dinâmicos](#install-dynamicmodules-pro) que você precisa.
Por fim, instale o [arquivo de licença](#install-license)
e remova as restrições.
## Distribuições
| Nome | Versões | Arquiteturas |
|-----------------------------------|--------------------------------|-------------------------------|
| [AlmaLinux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [Alpine](#install-alpine-pro) | 3.23, 3.22, 3.21 | x86-64, arm64 |
| [Alt](#install-alt-pro) | 11, 10 8 | x86-64, arm64 x86-64 |
| [Astra SE](#install-astrase-pro) | 4.7 1.8, 1.7 | arm64 x86-64 |
| [CentOS](#install-yum-pro) | 10, 9 | x86-64, arm64 |
| [Debian](#install-deb-pro) | 13, 12, 11 | x86-64, arm64 |
| [Fedora](#install-yum-pro) | 44, 43 | x86-64, arm64 |
| [FreeBSD](#install-freebsd-pro) | 15, 14 | x86-64, arm64 |
| [MSVSphere](#install-yum-pro) | 10, 9 8 | x86-64, arm64 x86-64 |
| [openSUSE](#install-opensuse-pro) | 16, 15 | x86-64, arm64 |
| [Oracle Linux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [OSNova](#install-osnova-pro) | 3.3.0, 2.13 | x86-64 |
| [RED OS](#install-yum-pro) | 8, 7 | x86-64, arm64 |
| [Rocky Linux](#install-yum-pro) | 10, 9, 8 | x86-64, arm64 |
| [ROSA](#install-yum-pro) | Chrome 13 Chrome 12 Fresh 12 | x86-64 x86-64, arm64 x86-64 |
| [SberLinux](#install-yum-pro) | 9 | x86-64 |
| [Ubuntu](#install-deb-pro) | 26.04, 24.04, 22.04 | x86-64, arm64 |
### Alma, CentOS, Fedora, MSVSphere, Oracle, RED OS, Rocky, ROSA, SberLinux
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde Colocar |
|-------------------|------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
3. Para adicionar o repositório,
crie o arquivo
`/etc/yum.repos.d/angie.repo`
com o seguinte conteúdo:
Alma
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/almalinux/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
CentOS
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/centos/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Fedora
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/fedora/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
MSVSphere
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/msvsphere/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Oracle
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/oracle/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
RED OS
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/redos/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
Rocky
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rocky/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Chrome
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rosa-chrome/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
ROSA Fresh
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/rosa/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
SberLinux
```ini
[angie-pro]
name=Angie PRO repo
baseurl=https://download.angie.software/angie-pro/sberlinux/$releasever/
sslclientcert=/etc/ssl/angie/angie-repo.crt
sslclientkey=/etc/ssl/angie/angie-repo.key
gpgcheck=1
enabled=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
4. Instale o pacote Angie PRO:
```console
$ sudo yum install -y angie-pro
$ # -- OU --
$ sudo dnf install -y angie-pro
```
5. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo yum install -y
$ # -- OU --
$ sudo dnf install -y
```
6. Inicie o serviço:
```console
$ sudo systemctl start angie
```
7. Para iniciar automaticamente o Angie PRO após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
### Alpine
1. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde Colocar |
|-------------------|------------------|---------------------|
| Certificado | `angie-repo.crt` | `/etc/apk/cert.pem` |
| Chave Privada | `angie-repo.key` | `/etc/apk/cert.key` |
2. Instale os pacotes auxiliares
para adicionar o repositório Angie PRO:
```console
$ sudo apk update
$ sudo apk add curl ca-certificates
```
3. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ sudo curl -o /etc/apk/keys/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Adicione o repositório Angie PRO:
```console
$ echo "https://download.angie.software/angie-pro/alpine/v$(egrep -o \
'[0-9]+\.[0-9]+' /etc/alpine-release)/main" \
| sudo tee -a /etc/apk/repositories > /dev/null
```
5. Atualize os índices do repositório:
```console
$ sudo apk update
```
6. Instale o pacote Angie PRO:
```console
$ sudo apk add angie-pro
```
7. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo apk add
```
8. Inicie o serviço:
```console
$ sudo service angie start
```
9. Para iniciar automaticamente o Angie PRO após a reinicialização do servidor:
```console
$ sudo rc-update add angie
```
### Alt
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde Colocar |
|-------------------|------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
3. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ curl -o ~/angie-signing.gpg https://angie.software/keys/angie-signing.gpg && \
sudo gpg --no-default-keyring --keyring /usr/lib/alt-gpgkeys/pubring.gpg --import ~/angie-signing.gpg
```
4. Salve a assinatura da chave:
```sh
$ echo 'simple-key "angie-pro" {
Fingerprint "EB8EAF3D4EF1B1ECF34865A2617AB978CB849A76";
Name "Angie PRO (Signing Key) ";
}' | sudo tee /etc/apt/vendors.list.d/angie.list > /dev/null
```
5. Adicione o repositório Angie PRO:
Alt 11
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux/11/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt 10
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 10
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux-sp/10/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
Alt SP 8
```console
$ echo "rpm [angie-pro] https://download.angie.software/angie-pro/altlinux-sp/8/ $(uname -m) main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Crie o arquivo de configuração `apt` do repositório Angie PRO
em `/etc/apt/apt.conf.d`:
```console
$ ( echo 'Acquire::https::Verify-Peer "true";';
echo 'Acquire::https::Verify-Host "true";';
echo 'Acquire::https::SslCert "/etc/ssl/angie/angie-repo.crt";';
echo 'Acquire::https::SslKey "/etc/ssl/angie/angie-repo.key";';
) | sudo tee -a /etc/apt/apt.conf >/dev/null
```
7. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
8. Instale o pacote Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
9. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo apt-get install -y
```
10. Inicie o serviço:
```console
$ sudo systemctl start angie
```
11. Para iniciar automaticamente o Angie PRO após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
### Astra SE
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde Colocar |
|-------------------|------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Restrinja o acesso ao diretório e arquivos:
```console
$ sudo chown -R _apt:nogroup /etc/ssl/angie/
```
3. Instale os pacotes auxiliares
para adicionar o repositório Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y apt-transport-https lsb-release \
ca-certificates curl gnupg2
```
4. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
5. Adicione o repositório Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/astra-se/$(egrep -o \
'[0-9]+\.[0-9]+' /etc/astra_version) unstable main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Para configurar o repositório, crie um arquivo
`/etc/apt/apt.conf.d/90download-angie`
com o seguinte conteúdo:
```console
Acquire::https::download.angie.software::Verify-Peer "true";
Acquire::https::download.angie.software::Verify-Host "true";
Acquire::https::download.angie.software::SslCert "/etc/ssl/angie/angie-repo.crt";
Acquire::https::download.angie.software::SslKey "/etc/ssl/angie/angie-repo.key";
```
7. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
8. (*Opcional*) Ao executar no modo Ambiente de Software Fechado
([CSE](https://wiki.astralinux.ru/pages/viewpage.action?pageId=41190634)),
instale o pacote de chave para verificar a autenticidade dos
arquivos executáveis do Angie PRO:
```console
$ sudo apt-get install -y angie-digsig-key
```
Atualize o CSE:
```console
$ sudo update-initramfs -uk all
```
Em seguida **reinicie o servidor**:
```console
$ sudo shutdown -r now
```
9. Instale o pacote Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
10. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo apt-get install -y
```
### Debian, Ubuntu
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde |
|-------------------|------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Restrinja o acesso ao diretório e arquivos:
```console
$ sudo chown -R _apt:nogroup /etc/ssl/angie/
```
3. Instale os pré-requisitos
para adicionar o repositório Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y apt-transport-https lsb-release \
ca-certificates curl gnupg2
```
4. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
5. Adicione o repositório Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/$(. /etc/os-release && echo "$ID/$VERSION_ID $VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
6. Para configurar o repositório, crie um arquivo chamado
`/etc/apt/apt.conf.d/90download-angie`
com o seguinte conteúdo:
```console
Acquire::https::download.angie.software::Verify-Peer "true";
Acquire::https::download.angie.software::Verify-Host "true";
Acquire::https::download.angie.software::SslCert "/etc/ssl/angie/angie-repo.crt";
Acquire::https::download.angie.software::SslKey "/etc/ssl/angie/angie-repo.key";
```
7. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
8. Instale o pacote Angie PRO:
```console
$ sudo apt-get install -y angie-pro
```
9. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo apt-get install -y
```
### OSNova
1. Instale os pré-requisitos
para adicionar o repositório Angie PRO:
```console
$ sudo apt-get update
$ sudo apt-get install -y ca-certificates curl
```
2. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
https://angie.software/keys/angie-signing.gpg
```
3. Adicione o repositório Angie PRO:
```console
$ echo "deb https://download.angie.software/angie-pro/osnova/$(egrep -o \
'[0-9]*' /etc/osnova_version | head -1) \
$(. /etc/os-release && echo "$VERSION_CODENAME") main" \
| sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
```
4. Atualize os índices do repositório:
```console
$ sudo apt-get update
```
5. Instale o pacote Angie PRO:
```console
$ sudo apt-get install -y angie
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo apt-get install -y
```
### FreeBSD
1. Para adicionar o repositório Angie PRO, crie estes diretórios:
```console
$ sudo mkdir -p /usr/local/etc/pkg/angie/ /usr/local/etc/pkg/repos/
```
2. Para configurar o repositório, crie um arquivo chamado
`/usr/local/etc/pkg/repos/angie.conf`
com o seguinte conteúdo:
```pkgconfig
angie: {
url: "https://download.angie.software/angie-pro/freebsd/${VERSION_MAJOR}/${ARCH}",
signature_type: "pubkey",
pubkey: "/usr/local/etc/pkg/angie/angie-signing.rsa",
enabled: yes
}
```
3. Baixe a chave pública do repositório Angie PRO
para verificação de pacotes:
```console
$ sudo curl -o /usr/local/etc/pkg/angie/angie-signing.rsa \
https://angie.software/keys/angie-signing.rsa
```
4. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde |
|-------------------|------------------|-------------------------------------------|
| Certificado | `angie-repo.crt` | `/usr/local/etc/pkg/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/usr/local/etc/pkg/angie/angie-repo.key` |
5. Adicione o certificado e a chave à configuração do gerenciador de pacotes:
```sh
$ echo '
PKG_ENV: {
SSL_CLIENT_CERT_FILE: "/usr/local/etc/pkg/angie/angie-repo.crt",
SSL_CLIENT_KEY_FILE: "/usr/local/etc/pkg/angie/angie-repo.key"
}' | sudo tee -a /usr/local/etc/pkg.conf > /dev/null
```
6. Atualize os índices do repositório:
```console
$ sudo pkg update
```
7. Instale o pacote Angie PRO:
```console
$ sudo pkg install -r angie -y angie-pro
```
8. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo pkg install -r angie -y
```
9. Inicie o serviço:
```console
$ sudo service angie start
```
10. Para iniciar automaticamente o Angie PRO após a reinicialização do servidor:
```console
$ sudo sysrc angie_enable=YES
```
#### NOTE
Como o gerenciador de pacotes do FreeBSD pode determinar incorretamente a versão mais recente,
use a seguinte abordagem para atualizar pacotes já instalados:
```console
$ sudo pkg upgrade `pkg search -r angie angie-pro-[0-9] | sort -Vr | head -1 | awk {'print $1'}`
```
### openSUSE
1. Crie o diretório `/etc/ssl/angie/`:
```console
$ sudo mkdir -p /etc/ssl/angie/
```
2. Transfira os arquivos que você recebeu com sua licença:
| Tipo de Arquivo | Nome Original | Onde |
|-------------------|------------------|---------------------------------|
| Certificado | `angie-repo.crt` | `/etc/ssl/angie/angie-repo.crt` |
| Chave Privada | `angie-repo.key` | `/etc/ssl/angie/angie-repo.key` |
Em seguida, combine-os em um pacote `/etc/ssl/angie/angie-repo-bundle.crt`:
```console
$ cat /etc/ssl/angie/angie-repo.crt /etc/ssl/angie/angie-repo.key | \
sudo tee -a /etc/ssl/angie/angie-repo-bundle.crt > /dev/null
```
3. Para adicionar o repositório, crie um arquivo chamado
`/etc/zypp/repos.d/angie.repo`
com o seguinte conteúdo:
```ini
[angie-pro]
enabled=1
autorefresh=1
baseurl=https://download.angie.software/angie-pro/opensuse/$releasever_major?ssl_clientcert=/etc/ssl/angie/angie-repo-bundle.crt&ssl_verify=peer
gpgcheck=1
gpgkey=https://angie.software/keys/angie-signing.gpg.asc
```
4. Atualize os índices do repositório:
```console
$ sudo zypper refresh
```
5. Instale o pacote Angie PRO:
```console
$ sudo zypper install -y angie-pro
```
6. (*Opcional*) Instale quaisquer pacotes [extras](#install-extras-pro)
que você precisar:
```console
$ sudo zypper install -y
```
7. Inicie o serviço:
```console
$ sudo systemctl start angie
```
8. Para iniciar automaticamente o Angie PRO após a reinicialização do servidor:
```console
$ sudo systemctl enable angie
```
## Extras
Além dos pacotes que fornecem funcionalidade principal,
também publicamos vários pacotes adicionais,
tanto nossos próprios quanto de fontes terceirizadas selecionadas.
### Painel Web Console Light
O Console Light é um
[painel web de monitoramento](https://pt.angie.software//angie/docs/configuration/monitoring.md#monitoring) leve para o Angie PRO,
publicado em nossos repositórios como o pacote `angie-pro-console-light`.
Ele é instalado da mesma forma que o pacote `angie` nas instruções acima;
para instruções de configuração, consulte a seção [Painel Web de Monitoramento Console Light](https://pt.angie.software//angie/docs/configuration/monitoring.md#monitoring).
### Módulos Dinâmicos
Para estender a funcionalidade básica do Angie PRO,
você pode adicionar vários módulos dinâmicos.
Você pode obtê-los como pacotes prontos do nosso repositório:
| [angie-pro-module-image-filter](https://pt.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) | Adiciona transformações de imagem para formatos JPEG, GIF, PNG e WebP. |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
| angie-pro-module-njs: [JS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js) (HTTP), [JS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) (stream) | Permite usar a linguagem njs (um subconjunto de JavaScript) na configuração do Angie PRO nos contextos `http` e `stream` respectivamente. |
| [angie-pro-module-perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) | Permite escrever manipuladores de `location` e variáveis em Perl, bem como chamar Perl a partir de SSI. |
| [angie-pro-module-xslt](https://pt.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) | Adiciona um filtro que transforma respostas XML usando templates XSLT. |
Para aplicar um módulo instalado em sua [configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile),
carregue-o usando a diretiva [load_module](https://pt.angie.software//angie/docs/configuration/modules/core.md#load-module) no contexto `main`:
```nginx
load_module modules/.so;
```
Uma ampla gama de [módulos de terceiros](https://pt.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules) também está disponível.
## Arquivo de Licença
Para configurar a licença para o Angie PRO:
1. Salve o arquivo de licença como `/etc/angie/license.pem`,
definindo as mesmas permissões que você usa para seus
[certificados de cliente](https://pt.angie.software//angie/docs/configuration/ssl.md#ssl-config).
2. Verifique se a licença é válida;
caso contrário, verifique os detalhes:
```console
$ sudo angie -t
angie: Valid license found:
angie: - owner: CN=Angie Client License
angie: - period: Jul 8 21:00:00 2024 GMT .. Jul 17 20:59:59 2024 GMT
angie:
angie: Limitations:
angie: - worker_processes_limit: 8
angie: - worker_connections_limit: 0
```
3. Monitore o console e os logs para quaisquer problemas de licenciamento.
Se a licença expirar durante a operação,
o Angie PRO emite periodicamente avisos correspondentes.
Além disso, ao recarregar, mensagens de erro de configuração aparecerão
se, por exemplo, o número de processos de trabalho
especificado nos termos da licença for excedido.
4. Modifique o arquivo `/etc/angie/angie.conf`;
após a instalação, dois parâmetros nele limitam a operação:
```nginx
worker_processes 1;
worker_connections 256;
```
Após salvar o arquivo de licença,
altere-os de acordo com os termos da sua licença, por exemplo:
```nginx
worker_processes 8;
worker_connections 65535;
```
# https://pt.angie.software/angie/docs/installation/external-modules.md
# Módulos de Terceiros
Além dos nossos próprios módulos dinâmicos para
[Angie](https://pt.angie.software//angie/docs/installation/oss_packages.md#install-dynamicmodules-oss) e [Angie PRO](https://pt.angie.software//angie/docs/installation/pro_packages.md#install-dynamicmodules-pro),
coletamos e publicamos pacotes para uma série de módulos populares de terceiros compatíveis com nginx,
desenvolvidos fora da nossa empresa, em nosso repositório.
## Instalação e Configuração
Os pacotes de módulos de terceiros são instalados do nosso repositório assim como nossos próprios pacotes:
- [Angie](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
- [Angie PRO](https://pt.angie.software//angie/docs/installation/pro_packages.md#pro-packages)
Para usar o módulo instalado na [configuração](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile),
carregue-o usando a diretiva [load_module](https://pt.angie.software//angie/docs/configuration/modules/core.md#load-module) no contexto `main`:
```nginx
load_module modules/.so;
```
#### NOTE
Não revisamos o código-fonte desses módulos
e não somos responsáveis pelas consequências de sua instalação;
os pacotes são compilados com base em numerosas solicitações
*exclusivamente* para conveniência do usuário.
## Lista de Módulos
| Módulo | Versão | Pacotes |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------|
| [Auth JWT](https://pt.angie.software//angie/docs/configuration/modules/external-modules/auth-jwt.md#external-auth-jwt) | [0.14.2](https://github.com/kjdev/nginx-auth-jwt) | `angie-module-auth-jwt` `angie-pro-module-auth-jwt` |
| [Auth LDAP](https://pt.angie.software//angie/docs/configuration/modules/external-modules/auth-ldap.md#external-ldap) | [241200e](https://github.com/kvspb/nginx-auth-ldap) | `angie-module-auth-ldap` `angie-pro-module-auth-ldap` |
| [Auth PAM](https://pt.angie.software//angie/docs/configuration/modules/external-modules/auth-pam.md#external-auth-pam) | [v1.5.5](https://github.com/sto/ngx_http_auth_pam_module) | `angie-module-auth-pam` `angie-pro-module-auth-pam` |
| [Auth SPNEGO](https://pt.angie.software//angie/docs/configuration/modules/external-modules/auth-spnego.md#external-auth-spnego) | [v1.1.3](https://github.com/stnoonan/spnego-http-auth-nginx-module) | `angie-module-auth-spnego` `angie-pro-module-auth-spnego` |
| [Auth TOTP](https://pt.angie.software//angie/docs/configuration/modules/external-modules/auth-totp.md#external-auth-totp) | [1.2.0](https://github.com/61131/nginx-http-auth-totp) | `angie-module-auth-totp` `angie-pro-module-auth-totp` |
| [Brotli](https://pt.angie.software//angie/docs/configuration/modules/external-modules/brotli.md#external-brotli) | [v1.0.0rc](https://github.com/google/ngx_brotli) | `angie-module-brotli` `angie-pro-module-brotli` |
| [Cache Purge](https://pt.angie.software//angie/docs/configuration/modules/external-modules/cache-purge.md#external-cache-purge) | [3.0.2](https://github.com/nginx-modules/ngx_cache_purge) | `angie-module-cache-purge` `angie-pro-module-cache-purge` |
| [CGI](https://pt.angie.software//angie/docs/configuration/modules/external-modules/cgi.md#external-cgi) | [v0.15](https://github.com/pjincz/nginx-cgi) | `angie-module-cgi` `angie-pro-module-cgi` |
| [Combined Upstreams](https://pt.angie.software//angie/docs/configuration/modules/external-modules/combined-upstreams.md#external-combined-upstreams) | [2.3.1](https://github.com/lyokha/nginx-combined-upstreams-module) | `angie-module-combined-upstreams` `angie-pro-module-combined-upstreams` |
| [DAV Ext](https://pt.angie.software//angie/docs/configuration/modules/external-modules/dav-ext.md#external-dav-ext) | [v4.0.1](https://github.com/arut/nginx-dav-ext-module) | `angie-module-dav-ext` `angie-pro-module-dav-ext` |
| [Dynamic Limit Req](https://pt.angie.software//angie/docs/configuration/modules/external-modules/dynamic-limit-req.md#external-dynamic-limit-req) | [1.9.3](https://github.com/limithit/ngx_dynamic_limit_req_module) | `angie-module-dynamic-limit-req` `angie-pro-module-dynamic-limit-req` |
| [Echo](https://pt.angie.software//angie/docs/configuration/modules/external-modules/echo.md#external-echo) | [v0.64](https://github.com/openresty/echo-nginx-module) | `angie-module-echo` `angie-pro-module-echo` |
| [Enhanced Memcached](https://pt.angie.software//angie/docs/configuration/modules/external-modules/enhanced-memcached.md#external-enhanced-memcached) | [v0.3](https://github.com/bpaquet/ngx_http_enhanced_memcached_module) | `angie-module-enhanced-memcached` `angie-pro-module-enhanced-memcached` |
| [Eval](https://pt.angie.software//angie/docs/configuration/modules/external-modules/eval.md#external-eval) | [2016.06.10](https://github.com/openresty/nginx-eval-module) | `angie-module-eval` `angie-pro-module-eval` |
| [GeoIP2](https://pt.angie.software//angie/docs/configuration/modules/external-modules/geoip2.md#external-geoip2) | [3.4](https://github.com/leev/ngx_http_geoip2_module) | `angie-module-geoip2` `angie-pro-module-geoip2` |
| [Headers More](https://pt.angie.software//angie/docs/configuration/modules/external-modules/headers-more.md#external-headers-more) | [v0.39](https://github.com/openresty/headers-more-nginx-module) | `angie-module-headers-more` `angie-pro-module-headers-more` |
| [HTTP Auth Radius](https://pt.angie.software//angie/docs/configuration/modules/external-modules/http-auth-radius.md#external-http-auth-radius) | [458af16](https://github.com/ten0s/ngx_http_auth_radius_module) | `angie-module-http-auth-radius` `angie-pro-module-http-auth-radius` |
| [JWT](https://pt.angie.software//angie/docs/configuration/modules/external-modules/jwt.md#external-jwt) | [v3.4.4](https://github.com/max-lt/nginx-jwt-module) | `angie-module-jwt` `angie-pro-module-jwt` |
| [Keyval](https://pt.angie.software//angie/docs/configuration/modules/external-modules/keyval.md#external-keyval) | [0.5.0](https://github.com/kjdev/nginx-keyval) | `angie-module-keyval` `angie-pro-module-keyval` |
| [Lua](https://pt.angie.software//angie/docs/configuration/modules/external-modules/lua.md#external-lua): [http_lua_module](https://github.com/openresty/lua-nginx-module), [stream_lua_module](https://github.com/openresty/stream-lua-nginx-module) | [0.10.31](https://github.com/openresty/lua-nginx-module) / [v0.0.17](https://github.com/openresty/stream-lua-nginx-module) | `angie-module-lua` `angie-pro-module-lua` |
| [ModSecurity](https://pt.angie.software//angie/docs/configuration/modules/external-modules/modsecurity.md#external-modsec) | [v1.0.4](https://github.com/owasp-modsecurity/ModSecurity-nginx) | `angie-module-modsecurity` `angie-pro-module-modsecurity` |
| [NJS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/njs.md#external-njs): [http_js](https://pt.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#http-js), [stream_js](https://pt.angie.software//angie/docs/configuration/modules/external-modules/stream_js.md#stream-js) | [1.0.0](https://nginx.org/en/docs/njs/) | `angie-module-njs` `angie-pro-module-njs` |
| [NDK](https://pt.angie.software//angie/docs/configuration/modules/external-modules/ndk.md#external-ndk) | [v0.3.4](https://github.com/vision5/ngx_devel_kit) | `angie-module-ndk` `angie-pro-module-ndk` |
| [OpenTracing](https://pt.angie.software//angie/docs/configuration/modules/external-modules/opentracing.md#external-opentracing) | [0.48.0](https://github.com/opentracing-contrib/nginx-opentracing) | `angie-module-opentracing` `angie-pro-module-opentracing` |
| [OpenTelemetry](https://pt.angie.software//angie/docs/configuration/modules/external-modules/otel.md#external-otel) | [v0.1.2](https://github.com/nginxinc/nginx-otel) | `angie-module-otel` `angie-pro-module-otel` |
| [PostgreSQL](https://pt.angie.software//angie/docs/configuration/modules/external-modules/postgres.md#external-postgres) | [1.0rc7](https://github.com/FRiCKLE/ngx_postgres) | `angie-module-postgres` `angie-pro-module-postgres` |
| [Redis2](https://pt.angie.software//angie/docs/configuration/modules/external-modules/redis2.md#external-redis2) | [v0.15](https://github.com/openresty/redis2-nginx-module) | `angie-module-redis2` `angie-pro-module-redis2` |
| [RTMP](https://pt.angie.software//angie/docs/configuration/modules/external-modules/rtmp.md#external-rtmp) | [v1.2.2](https://github.com/arut/nginx-rtmp-module) | `angie-module-rtmp` `angie-pro-module-rtmp` |
| [Set Misc](https://pt.angie.software//angie/docs/configuration/modules/external-modules/set-misc.md#external-set-misc) | [v0.33](https://github.com/openresty/set-misc-nginx-module) | `angie-module-set-misc` `angie-pro-module-set-misc` |
| [Subs](https://pt.angie.software//angie/docs/configuration/modules/external-modules/subs.md#external-subs) | [e12e965](https://github.com/yaoweibin/ngx_http_substitutions_filter_module) | `angie-module-subs` `angie-pro-module-subs` |
| [TestCookie](https://pt.angie.software//angie/docs/configuration/modules/external-modules/testcookie.md#external-testcookie) | [7d263d4](https://github.com/kyprizel/testcookie-nginx-module) | `angie-module-testcookie` `angie-pro-module-testcookie` |
| [UnBrotli](https://pt.angie.software//angie/docs/configuration/modules/external-modules/unbrotli.md#external-unbrotli) | [60bed63](https://github.com/clyfish/ngx_unbrotli) | `angie-module-unbrotli` `angie-pro-module-unbrotli` |
| [Upload](https://pt.angie.software//angie/docs/configuration/modules/external-modules/upload.md#external-upload) | [2.3.0](https://github.com/fdintino/nginx-upload-module) | `angie-module-upload` `angie-pro-module-upload` |
| [VOD](https://pt.angie.software//angie/docs/configuration/modules/external-modules/vod.md#external-vod) | [1.9.0](https://github.com/kaltura/nginx-vod-module) | `angie-module-vod` `angie-pro-module-vod` |
| [VTS](https://pt.angie.software//angie/docs/configuration/modules/external-modules/vts.md#external-vts): [module-vts](https://github.com/vozlt/nginx-module-vts), [module-sts](https://github.com/vozlt/nginx-module-sts), [module-stream-sts](https://github.com/vozlt/nginx-module-stream-sts) | [v0.2.5](https://github.com/vozlt/nginx-module-vts) / [v0.1.1](https://github.com/vozlt/nginx-module-sts) / [v0.1.1](https://github.com/vozlt/nginx-module-stream-sts) | `angie-module-vts` `angie-pro-module-vts` |
| [ZIP](https://pt.angie.software//angie/docs/configuration/modules/external-modules/zip.md#external-zip) | [1.3.0](https://github.com/evanmiller/mod_zip) | `angie-module-zip` `angie-pro-module-zip` |
| [Zstd](https://pt.angie.software//angie/docs/configuration/modules/external-modules/zstd.md#external-zstd) | [f4ba115](https://github.com/tokers/zstd-nginx-module) | `angie-module-zstd` `angie-pro-module-zstd` |
# https://pt.angie.software/angie/docs/installation/thirdparty.md
# Repositórios de Terceiros para o Angie
Recomendamos usar nossos pacotes oficiais para instalar o Angie:
- [Angie](https://pt.angie.software//angie/docs/installation/oss_packages.md#oss-packages)
- [Angie PRO](https://pt.angie.software//angie/docs/installation/pro_packages.md#pro-packages)
Se você deseja usar repositórios de terceiros
que são específicos para seu sistema ou distribuição,
as seguintes opções estão atualmente disponíveis.
Repositórios oficiais de várias distribuições Linux:
- [Alt Linux](https://packages.altlinux.org/ru/sisyphus/srpms/angie/)
- [Arch User Repository](https://aur.archlinux.org/packages/angie)
- [FreeBSD FreshPorts](https://www.freshports.org/www/angie/)
- [nixpkgs](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/servers/http/angie/default.nix)
- [ROSA Linux ABF](https://abf.io/import/angie/)
Gerenciadores de pacotes para macOS:
- [Homebrew](https://github.com/stychos/homebrew-angie):
```console
$ brew tap stychos/angie
$ brew install stychos/angie/angie
```
- [MacPorts](https://github.com/macports/macports-ports/tree/master/www/angie):
```console
$ sudo port install angie
```
Para uma lista adicional de fontes de terceiros, veja [aqui](https://repology.org/project/angie/versions).
#### NOTE
Não publicamos nada nesses repositórios
e não somos responsáveis pelas consequências da instalação de software a partir deles.
# https://pt.angie.software/angie/docs/configuration.md
# Configuração
Esta página contém artigos, referências, índices e instruções
para configurar o Angie.
## Informações Gerais
Estes artigos cobrem instalação e configuração do Angie,
inicialização e parada do servidor web, gerenciamento dele,
bem como vários aspectos do processamento de requisições
e interação com outros servidores.
* [Configuração](https://pt.angie.software//angie/docs/configuration/configfile.md)
* [Gerenciamento](https://pt.angie.software//angie/docs/configuration/runtime.md)
* [Conexões, Sessões, Requisições, Logs](https://pt.angie.software//angie/docs/configuration/processing.md)
## Referências e Índices
Estas seções de resumo fornecem informações de referência sobre módulos integrados,
exemplos de sua configuração, bem como diretivas e variáveis suportadas.
* [Módulos](https://pt.angie.software//angie/docs/configuration/modules/index.md)
* [Variáveis](https://pt.angie.software//angie/docs/configuration/varindex.md)
* [Referência da API NJS](https://pt.angie.software//angie/docs/configuration/njs-reference.md)
Você também pode usar o serviço de links curtos em [https://angie.ws/](https://angie.ws/)
para encontrar rapidamente diretivas e variáveis individuais:
* [Acesso Rápido](https://pt.angie.software//angie/docs/configuration/quickaccess.md)
## Instruções
Instruções passo a passo para aspectos específicos da configuração do Angie são fornecidas aqui.
* [Configurando ACME](https://pt.angie.software//angie/docs/configuration/acme.md)
* [Configurando clusters](https://pt.angie.software//angie/docs/configuration/cluster.md)
* [Configurando OIDC](https://pt.angie.software//angie/docs/configuration/oidc.md)
* [Configurando SSL](https://pt.angie.software//angie/docs/configuration/ssl.md)
* [Diretivas nginx Não Suportadas](https://pt.angie.software//angie/docs/configuration/nginx-unsupported-directives.md)
* [Migrando do nginx](https://pt.angie.software//angie/docs/configuration/migration.md)
* [Métricas personalizadas](https://pt.angie.software//angie/docs/configuration/custom-metrics.md)
* [Painel Console Light](https://pt.angie.software//angie/docs/configuration/monitoring.md)
* [Painel Grafana](https://pt.angie.software//angie/docs/configuration/grafana.md)
## Materiais da Comunidade
Coletamos recursos da comunidade que ajudarão você a entender melhor
a configuração e o uso do Angie.
### Artigos
- [Angie: A New NGINX Fork Developed by Some of Its Former Devs](https://linuxiac.com/angie-web-server-is-a-new-nginx-fork/)
no Linuxiac
- [What's New in the Angie 1.9 Web Server (an nginx fork) and What to Expect from 1.10?](https://habr.com/en/articles/911444/)
no Habr
### Cursos
Cursos em português sobre o Angie não estão disponíveis no momento.
Consulte a documentação oficial do Angie e os guias práticos abaixo.
### Guias Práticos
- [Migrating from Nginx to Angie: A Real-World Journey from Certbot to Built-in ACME](https://dev.to/stan-breaks/migrating-from-nginx-to-angie-a-real-world-journey-from-certbot-to-built-in-acme-7a3)
no DEV Community
### Entrevistas e Podcasts
- "NGINX is Dead? // Angie Web Server Migration Guide" by DevOps Toolbox
([YouTube](https://www.youtube.com/watch?v=HFCtaiJMDGg), 27.03.2026)
- "Nginx Has a BIG Problem..." by DevOps Toolbox ([YouTube](https://www.youtube.com/watch?v=acJBNVTW42I), 30.01.2026)
## Documentação para assistentes de IA
O site publica cópias legíveis por máquina de todas as páginas da
documentação para que ferramentas baseadas em LLM — Claude Code,
Cursor, ChatGPT e outros assistentes agênticos — possam ingerir o
conteúdo diretamente em vez de extrair HTML renderizado.
### llms.txt e llms-full.txt
Cada subdomínio de idioma serve um sitemap
[llms.txt](https://llmstxt.org/) com uma breve descrição do
projeto e uma lista de todas as páginas (título, URL absoluta,
anotação). Seu arquivo complementar `llms-full.txt` concatena o
conteúdo Markdown completo de cada página em um único arquivo
adequado para ingestão de uma só vez:
- [https://pt.angie.software/llms.txt](https://pt.angie.software/llms.txt)
- [https://pt.angie.software/llms-full.txt](https://pt.angie.software/llms-full.txt)
Essas URLs também são anunciadas em
[robots.txt](https://pt.angie.software/robots.txt) pela diretiva
`Llms:`, de modo que rastreadores LLM as descobrem automaticamente.
### Versões em Markdown das páginas
Toda página HTML tem uma versão Markdown correspondente. Para obter a
versão Markdown de qualquer URL da documentação, substitua a barra
final por `.md`:
- HTML: [https://pt.angie.software/angie/docs/configuration/](https://pt.angie.software/angie/docs/configuration/)
- Markdown: [https://pt.angie.software/angie/docs/configuration.md](https://pt.angie.software/angie/docs/configuration.md)
O Markdown é gerado a partir do mesmo código-fonte reStructuredText
que o HTML, portanto o conteúdo permanece sempre sincronizado.
### Context7
A documentação do Angie está indexada no
[Context7](https://context7.com/), um registro que fornece
documentação atualizada de bibliotecas a editores de código de IA por
meio de seu servidor MCP. A ficha em português do Angie está em
[https://context7.com/websites/pt_angie_software_angie](https://context7.com/websites/pt_angie_software_angie).
# https://pt.angie.software/angie/docs/configuration/configfile.md
# Arquivos de Configuração
O Angie usa um arquivo de configuração baseado em texto. Por padrão, este arquivo é nomeado
`angie.conf` e está localizado de acordo com o parâmetro de compilação
[--conf-path](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths), tipicamente no diretório `/etc/angie`.
Um arquivo de configuração geralmente consiste nos seguintes contextos:
- [events](https://pt.angie.software//angie/docs/configuration/modules/core.md#events) – Processamento geral de conexões
- [http](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#d-http) – Tráfego HTTP
- [mail](https://pt.angie.software//angie/docs/configuration/modules/mail/index.md#m-mail) – Tráfego de email
- [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-stream) – Tráfego TCP e UDP
- [wasm_modules](https://pt.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-modules) – Runtime WASM
Diretivas que são colocadas fora desses contextos são consideradas como estando no
contexto `main`:
```nginx
user angie; # uma diretiva no contexto 'main'
events {
# configuração do processamento de conexões
}
http {
# Configuração específica para HTTP e que afeta todos os servidores virtuais
server {
# configuração do servidor virtual HTTP 1
location /one {
# configuração para processar URIs que começam com '/one'
}
location /two {
# configuração para processar URIs que começam com '/two'
}
}
server {
# configuração do servidor virtual HTTP 2
}
}
stream {
# Configuração específica para TCP/UDP e que afeta todos os servidores virtuais
server {
# configuração do servidor virtual TCP 1
}
}
```
Para simplificar o gerenciamento da configuração, recomendamos usar a diretiva [include](https://pt.angie.software//angie/docs/configuration/modules/core.md#include)
no arquivo principal `angie.conf` para referenciar o conteúdo de
arquivos específicos por funcionalidade:
```nginx
include /etc/angie/http.d/*.conf;
include /etc/angie/stream.d/*.conf;
```
## Herança
Em geral, um contexto filho (aquele que está contido dentro de outro contexto, que
é considerado seu pai) herda as configurações das diretivas definidas no
nível pai. Algumas diretivas podem aparecer em múltiplos contextos; nesses casos,
você pode sobrescrever as configurações herdadas do pai incluindo a
diretiva no contexto filho.
## Sintaxe
### Unidades de Medida
Você pode especificar tamanhos usando as seguintes unidades:
| Sem sufixo | Bytes |
|--------------|-----------|
| `k`, `K` | Kilobytes |
| `m`, `M` | Megabytes |
| `g`, `G` | Gigabytes |
Por exemplo: `1024`, `8k`, `1m`, `16g`.
Intervalos de tempo podem ser especificados em milissegundos, segundos, minutos, horas, dias,
e assim por diante, usando os seguintes sufixos:
| `ms` | Milissegundos |
|--------|-----------------------------------------|
| `s` | Segundos |
| `m` | Minutos |
| `h` | Horas |
| `d` | Dias |
| `w` | Semanas |
| `M` | Meses (assumidos como iguais a 30 dias) |
| `y` | Anos (assumidos como iguais a 365 dias) |
Múltiplas unidades podem ser combinadas em um único valor especificando-as em ordem
da mais significativa para a menos significativa, opcionalmente separadas por
espaços em branco. Por exemplo, `"1h 30m"` especifica a mesma duração que
`"90m"` ou `"5400s"`. Um valor sem sufixo é interpretado como
segundos. É recomendado sempre especificar um sufixo.
Alguns intervalos de tempo só podem ser especificados com resolução de segundos.
### Diretivas
Cada diretiva consiste em um nome e um conjunto de parâmetros.
Se qualquer parte de uma diretiva precisar conter espaços,
ela deve ser colocada entre aspas ou escapar os espaços:
```nginx
add_header X-MyHeader "foo bar";
add_header X-MyHeader foo\ bar;
```
Se um parâmetro nomeado precisar de espaços e você usar aspas,
seu nome também deve ser colocado entre aspas:
```nginx
server example.com "sid=server 1";
```
### Strings com variáveis
Muitas diretivas aceitam uma *string com variáveis* (também chamada de *valor
complexo*): um valor de parâmetro que combina texto literal com referências a
variáveis como `$name`, `${name}` e as variáveis de captura de expressões
regulares de `$1` a `$9`. Esse valor é compilado uma única vez quando a
configuração é carregada e reavaliado a cada requisição ou conexão, de modo que
a string resultante pode variar de uma requisição para outra. Um valor que não
contém `$` se comporta como um literal simples e não acrescenta sobrecarga por
requisição.
Use a forma com chaves `${name}` para separar o nome de uma variável do texto
que vem imediatamente em seguida, como em `${name}_suffix`. As variáveis de
captura de `$1` a `$9` só estão disponíveis onde uma expressão regular com os
grupos correspondentes tenha coincidido, e exigem uma compilação com PCRE.
Não há escape de `$` por barra invertida. Para incluir um `$` literal, defina
uma variável que o contenha, por exemplo com [map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#id1) ou [set](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#set), e
referencie essa variável no valor.
O conjunto de variáveis disponíveis depende do contexto: as do subsistema
[http](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#d-http) diferem das do subsistema [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-stream); consulte
o [índice de variáveis](https://pt.angie.software//angie/docs/configuration/varindex.md#varindex) para ver a lista completa. As variáveis
são geradas tanto pelos módulos integrados quanto por diretivas como [map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#id1),
[geo](https://pt.angie.software//angie/docs/configuration/modules/http/http_geo.md#id1) e [split_clients](https://pt.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#id1).
Para algumas diretivas a presença de uma variável altera o comportamento em tempo
de execução: o valor é então resolvido dinamicamente a cada requisição em vez de
ser fixado quando a configuração é carregada, o que pode exigir um
[resolver](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver). A diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) é um desses casos.
## Configurando Hashes
Para processar eficientemente conjuntos estáticos de dados, como nomes de servidor, valores da diretiva [map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#id1),
tipos MIME e nomes de cabeçalhos de requisição, o Angie utiliza tabelas
hash. Durante a inicialização e cada reconfiguração, o Angie determina o
tamanho ótimo para essas tabelas hash para garantir que o tamanho do bucket, que armazena
chaves com valores hash idênticos, não exceda o parâmetro configurado (hash
bucket size). O tamanho da tabela é medido em buckets e é ajustado até exceder
o parâmetro hash max size. A maioria das tabelas hash têm diretivas correspondentes
para ajustar esses parâmetros, como [server_names_hash_max_size](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-names-hash-max-size)
e [server_names_hash_bucket_size](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-names-hash-bucket-size) para nomes de servidor.
O parâmetro hash bucket size é alinhado a um múltiplo do tamanho da
linha de cache do processador. Este alinhamento melhora a eficiência da busca de chaves em
processadores modernos reduzindo o número de acessos à memória. Se o hash bucket size
for igual ao tamanho de uma linha de cache, o número máximo de acessos à memória durante uma
busca de chave será dois: um para calcular o endereço do bucket e outro para buscar
dentro do bucket. Portanto, se o Angie indicar que o hash max
size ou hash bucket size deve ser aumentado, comece aumentando o hash
max size.
### Recarregando a Configuração
Para aplicar mudanças no arquivo de configuração, ele deve ser recarregado. Você pode
reiniciar o processo do Angie com uma verificação de sintaxe da configuração antes:
```console
$ sudo angie -t && sudo service angie restart
```
Alternativamente, você pode recarregar o serviço para aplicar a nova configuração sem
interromper o processamento das requisições atuais:
```console
$ sudo angie -t && sudo service angie reload
```
# https://pt.angie.software/angie/docs/configuration/runtime.md
# Controle em Tempo de Execução
Para iniciar o Angie, use o **systemd** com o seguinte comando:
```console
$ sudo service angie start
```
É recomendado verificar a sintaxe da configuração antecipadamente. Veja como:
```console
$ sudo angie -t && sudo service angie start
```
Para recarregar a configuração:
```console
$ sudo angie -t && sudo service angie reload
```
Para parar o Angie:
```console
$ sudo service angie stop
```
Após a instalação, execute o seguinte comando para garantir que o Angie esteja
funcionando:
```console
$ curl localhost:80
```
#### NOTE
Os métodos para executar a versão de código aberto do Angie podem variar
dependendo do método de instalação.
O Angie possui um processo mestre e vários processos trabalhadores. O processo
mestre é responsável por ler e avaliar a configuração e manter os processos
trabalhadores. Os processos trabalhadores lidam com o processamento real das
requisições. O Angie usa um modelo baseado em eventos e mecanismos dependentes
do SO para distribuir eficientemente as requisições entre os processos
trabalhadores. O número de processos trabalhadores é definido no arquivo de
configuração e pode ser fixo para uma determinada configuração ou ajustado
automaticamente com base no número de núcleos de CPU disponíveis (veja
[worker_processes](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-processes)).
Quando configurado, o Angie também descarregará certas zonas de memória
compartilhada (atualmente, a `keys_zone` em [proxy_cache_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path))
para o disco antes de sair,
para que o novo processo mestre possa restaurá-las
e assim melhorar o desempenho.
Se a restauração falhar devido a uma mudança no tamanho da zona,
incompatibilidade de versão binária ou outras razões,
o Angie registrará um alerta (`failed to restore zone at address`)
e não usará o mecanismo de restauração de zona.
## Usando Sinais
O Angie também pode ser controlado usando sinais. Por padrão, o ID do processo
do processo mestre é escrito no arquivo `/run/angie.pid`. Este nome de
arquivo pode ser alterado no momento da configuração ou em `angie.conf`
usando a diretiva [pid](https://pt.angie.software//angie/docs/configuration/modules/core.md#pid). O processo mestre suporta os seguintes sinais:
| `TERM`, `INT` | Desligamento rápido |
|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `QUIT` | Desligamento [gracioso](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) |
| `HUP` | Recarregar configuração, atualizar fuso horário (apenas para FreeBSD e Linux), iniciar novos processos trabalhadores com a configuração atualizada, desligar [graciosamente](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) os processos trabalhadores antigos |
| `USR1` | Reabrir arquivos de log |
| `USR2` | Atualizar o arquivo executável |
| `WINCH` | Desligamento [gracioso](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) dos processos trabalhadores |
Você pode enviar sinais usando **kill**:
```console
$ sudo kill -QUIT $(cat /run/angie.pid)
```
Processos trabalhadores individuais também podem ser controlados usando sinais,
embora isso seja opcional. Os sinais suportados são:
| `TERM`, `INT` | Desligamento rápido |
|-----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `QUIT` | Desligamento [gracioso](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout) |
| `USR1` | Reabrir arquivos de log |
| `WINCH` | Terminação anormal para depuração (requer que [debug_points](https://pt.angie.software//angie/docs/configuration/modules/core.md#debug-points) esteja habilitado) |
## Alterando Configuração
Para que o Angie releia o arquivo de configuração, um sinal `HUP` deve
ser enviado ao processo mestre. O processo mestre primeiro verifica a validade
da sintaxe e então tenta aplicar a nova configuração, que inclui abrir novos
arquivos de log e sockets de escuta. Se a aplicação da nova configuração
falhar, o processo mestre reverte as mudanças e continua operando com a
configuração antiga. Se a aplicação for bem-sucedida, o processo mestre inicia
novos processos trabalhadores e envia mensagens aos processos trabalhadores
antigos, solicitando que eles desliguem [graciosamente](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout). Os processos trabalhadores antigos fecham seus
sockets de escuta e continuam a atender clientes existentes. Depois que todos
os clientes foram atendidos, os processos trabalhadores antigos são desligados.
O Angie rastreia mudanças de configuração para cada processo. Os números de
geração começam em 1 quando o servidor é iniciado pela primeira vez. Esses
números são incrementados a cada recarga de configuração e são visíveis nos
títulos dos processos:
```console
$ sudo angie
$ ps aux | grep angie
angie: master process v1.12.1 #1 [angie]
angie: worker process #1
```
Após uma recarga de configuração bem-sucedida (independentemente de haver
mudanças reais), o Angie incrementa o número de geração para processos que
receberam a nova configuração:
```console
$ sudo kill -HUP $(cat /run/angie.pid)
$ ps aux | grep angie
angie: master process v1.12.1 #2 [angie]
angie: worker process #2
```
Se quaisquer processos trabalhadores de gerações anteriores continuarem a
operar, eles se tornarão imediatamente visíveis:
```console
$ ps aux | grep angie
angie: worker process #1
angie: worker process #2
```
#### NOTE
Não confunda o número de geração da configuração com um 'número de processo';
o Angie não usa numeração contínua de processos para fins práticos.
## Rotação de Arquivos de Log
Para rotacionar arquivos de log, primeiro renomeie os arquivos. Em seguida,
envie um sinal `USR1` ao processo mestre. O processo mestre reabrirá
todos os arquivos de log atualmente abertos e os atribuirá a um usuário sem
privilégios sob o qual os processos trabalhadores estão executando. Após
reabrir com sucesso os arquivos, o processo mestre fecha todos os arquivos
abertos e notifica os processos trabalhadores para reabrirem seus arquivos de
log. Os processos trabalhadores também abrirão os novos arquivos e fecharão os
antigos imediatamente. Como resultado, os arquivos antigos ficam disponíveis
para pós-processamento, como compressão, quase imediatamente.
## Atualização de Executável em Tempo Real
Para atualizar o executável do servidor, primeiro substitua o arquivo
executável antigo pelo novo. Em seguida, envie um sinal `USR2` ao
processo mestre. O processo mestre renomeará seu arquivo atual com o ID do
processo para um novo arquivo com o sufixo `.oldbin`, por exemplo,
`/usr/local/angie/logs/angie.pid.oldbin`, e então iniciará o novo
executável, que por sua vez inicia novos processos trabalhadores.
Note que o processo mestre antigo não fecha seus sockets de escuta e pode ser
gerenciado para reiniciar seus processos trabalhadores se necessário. Se o novo
executável não funcionar como esperado, você pode tomar uma das seguintes ações:
* Envie o sinal `HUP` ao processo mestre antigo. Isso iniciará novos
processos trabalhadores sem reler a configuração. Você pode então desligar
todos os novos processos [graciosamente](https://pt.angie.software//angie/docs/configuration/modules/core.md#worker-shutdown-timeout)
enviando o sinal `QUIT` ao novo processo mestre.
* Envie o sinal `TERM` ao novo processo mestre. Ele enviará uma mensagem
aos seus processos trabalhadores, solicitando que saiam imediatamente. Se
quaisquer processos não saírem, envie o sinal `KILL` para forçá-los a
sair. Quando o novo processo mestre sair, o processo mestre antigo iniciará
automaticamente novos processos trabalhadores.
Se o novo processo mestre sair, o processo mestre antigo removerá o sufixo
`.oldbin` do nome do arquivo com o ID do processo.
Se a atualização for bem-sucedida, envie o sinal `QUIT` ao processo
mestre antigo, e apenas os novos processos permanecerão.
Quando configurado, o Angie também descarregará certas zonas de memória
compartilhada (atualmente, a `keys_zone` em [proxy_cache_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path))
para o disco antes de atualizar,
para que o novo processo mestre possa restaurá-las
e assim melhorar o desempenho.
Se a restauração falhar devido a uma mudança no tamanho da zona,
incompatibilidade de versão binária ou outras razões,
o Angie registrará um alerta (`failed to restore zone at address`)
e não usará o mecanismo de restauração de zona.
## Opções de Linha de Comando
| `-?`, `-h` | Exibe ajuda para parâmetros de linha de comando e sai. |
|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--build-env` | Exibe informações auxiliares sobre o ambiente de compilação e sai. |
| `-c` arquivo | Usa arquivo como o arquivo de configuração em vez do [arquivo padrão](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile). |
| `-e` arquivo | Usa arquivo como o arquivo de log de erro em vez do [arquivo padrão](https://pt.angie.software//angie/docs/configuration/processing.md#logging). O valor especial `stderr` especifica a saída de erro padrão. |
| `-g` diretivas | Define [diretivas de configuração global](https://pt.angie.software//angie/docs/configuration/modules/core.md#core), por exemplo: `angie -g "pid /var/run/angie.pid; worker_processes `sysctl -n hw.ncpu`;"`. |
| `-m`, `-M` | Exibe uma lista de módulos integrados (`-m`) ou integrados e carregados (`-M`) e sai. |
| `-p` prefixo | Usa o caminho prefixo especificado para `angie` (o diretório onde os arquivos do servidor estão localizados; o padrão é `/usr/local/angie/`). |
| `-q` | Exibe apenas mensagens de erro se `-t` ou `-T` estiver definido; caso contrário, não tem efeito. |
| `-s` sinal | Envia um [sinal](#control-signals) para o processo mestre: `stop`, `quit`, `reopen`, `reload`, e assim por diante. |
| `-t` | Testa o arquivo de configuração e sai. O Angie verifica a sintaxe da configuração, incluindo recursivamente arquivos mencionados nele. |
| `-T` | Igual ao `-t`, mas também exibe o resumo da configuração na saída padrão após incluir recursivamente todos os arquivos mencionados na configuração. |
| `-v` | Exibe a versão do Angie e sai. |
| `-V` | Exibe a versão do Angie, versão do compilador, tempo de compilação e os [parâmetros de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure) usados, e sai. |
# https://pt.angie.software/angie/docs/configuration/processing.md
# Conexões, Sessões, Requisições, Logs
## Mecanismos de processamento de conexão
O Angie suporta vários métodos de processamento de conexão. A disponibilidade de
um método específico depende da plataforma sendo utilizada. Em plataformas que
suportam múltiplos métodos, o Angie normalmente seleciona o método mais
eficiente automaticamente. No entanto, se necessário, um método de processamento
de conexão pode ser explicitamente escolhido usando a diretiva [use](https://pt.angie.software//angie/docs/configuration/modules/core.md#use).
Os seguintes métodos de processamento de conexão estão disponíveis:
| Método | Descrição |
|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `select` | Um método padrão. O módulo de suporte é construído automaticamente em plataformas que não possuem métodos mais eficientes. As opções de construção `--with-select_module` e `--without-select_module` podem ser usadas para forçar a habilitação ou desabilitação da construção deste módulo. |
| `poll` | Um método padrão. O módulo de suporte é construído automaticamente em plataformas que não possuem métodos mais eficientes. As opções de construção `--with-poll_module` e `--without-poll_module` podem ser usadas para forçar a habilitação ou desabilitação da construção deste módulo. |
| `kqueue` | Um método eficiente disponível no FreeBSD 4.1+, OpenBSD 2.9+, NetBSD 2.0, e macOS. |
| `epoll` | Um método eficiente disponível no Linux 2.6+. |
| `/dev/poll` | Um método eficiente disponível no Solaris 7 11/99+, HP/UX 11.22+ (eventport), IRIX 6.5.15+, e Tru64 UNIX 5.1A+. |
| `eventport` | O método `event ports` está disponível no Solaris 10+. (Devido a problemas conhecidos, é recomendado usar o método `/dev/poll` em seu lugar.) |
## Processamento de requisições HTTP
Uma requisição HTTP passa por uma série de fases, onde um tipo específico de
processamento é realizado em cada fase.
| `Post-read` | A fase inicial. O módulo [RealIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip) é invocado durante esta fase. |
|------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `Server-rewrite` | A fase onde as diretivas do módulo [Rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite), definidas em um bloco `server` (mas fora de um bloco `location`), são processadas. |
| `Find-config` | Uma fase especial onde um [location](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#location) é selecionado baseado na URI da requisição. |
| `Rewrite` | Similar à fase `Server-rewrite`, mas se aplica às regras [rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5) definidas dentro do bloco location selecionado na fase anterior. |
| `Post-rewrite` | Uma fase especial onde a requisição é redirecionada para um novo location, como na fase `Find-config`, se sua URI foi modificada durante a fase `Rewrite`. |
| `Preaccess` | Durante esta fase, módulos padrão do Angie como [Limit Req](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) registram seus manipuladores. |
| `Access` | A fase onde a autorização do cliente para fazer a requisição é verificada, normalmente invocando módulos padrão do Angie como [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic). |
| `Post-access` | Uma fase especial onde a diretiva [satisfy any](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#satisfy) é processada. |
| `Precontent` | Diretivas de módulos padrão, como [try_files](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#try-files) e [mirror](https://pt.angie.software//angie/docs/configuration/modules/http/http_mirror.md#id1), registram seus manipuladores durante esta fase. |
| `Content` | A fase onde a resposta é normalmente gerada. Múltiplos módulos padrão do Angie registram seus manipuladores neste estágio, incluindo [Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index). As diretivas [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass), [scgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass) e [grpc_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-pass) também são tratadas aqui.
Os manipuladores são chamados sequencialmente até que um deles produza a saída. |
| `Log` | A fase final, onde o registro da requisição é realizado. Atualmente, apenas o módulo [Log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#http-log) registra seu manipulador neste estágio para registro de acesso. |
## Processamento de sessões TCP/UDP
Uma sessão TCP/UDP de um cliente passa por uma série de fases, onde um
tipo específico de processamento é realizado em cada fase:
| `Post-accept` | A fase inicial após aceitar uma conexão do cliente. O módulo [RealIP](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip) é invocado nesta fase. |
|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `Pre-access` | Uma fase preliminar para verificar o acesso. Os módulos [Set](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) são invocados durante esta fase. |
| `Access` | A fase para limitar o acesso do cliente antes do processamento real dos dados. O módulo [Access](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) é invocado neste estágio. |
| `SSL` | A fase onde ocorre a terminação TLS/SSL. O módulo [SSL](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) é invocado durante esta fase. |
| `Preread` | A fase para ler os bytes iniciais de dados no [buffer de preread](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-preread-buffer-size) para permitir que módulos como [SSL Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) analisem os dados antes do processamento. |
| `Content` | Uma fase obrigatória onde os dados são realmente processados, normalmente envolvendo o módulo [Return](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) para enviar uma resposta ao cliente. A diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-pass) também é tratada aqui. |
| `Log` | A fase final onde o resultado do processamento da sessão do cliente é registrado. O módulo [Log](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_log.md#stream-log) é invocado nesta fase. |
## Processamento de requisições
### Seleção de servidor virtual
Inicialmente, uma conexão é criada dentro do contexto de um servidor padrão. O
nome do servidor pode então ser determinado nas seguintes etapas do processamento
da requisição, cada uma das quais está envolvida na seleção da configuração do servidor:
- Durante o handshake SSL, antecipadamente, de acordo com o SNI.
- Após processar a linha de requisição.
- Após processar o campo de cabeçalho `Host`.
Se o nome do servidor não for determinado após processar a linha de requisição ou o
campo de cabeçalho `Host`, o Angie usará um nome vazio como nome do servidor.
Em cada uma dessas etapas, diferentes configurações de servidor podem ser aplicadas.
Portanto, certas diretivas devem ser especificadas com cuidado:
- No caso da diretiva [ssl_protocols](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-protocols), a lista de protocolos é definida pela
biblioteca OpenSSL antes que a configuração do servidor seja aplicada de acordo com
o nome solicitado através do SNI. Como resultado, os protocolos devem ser especificados
apenas para o servidor padrão.
- As diretivas [client_header_buffer_size](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#client-header-buffer-size) e [merge_slashes](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#merge-slashes) são
aplicadas antes de ler a linha de requisição. Portanto, essas diretivas usam
a configuração do servidor padrão ou a configuração do servidor escolhida por
SNI.
- No caso das diretivas [ignore_invalid_headers](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#ignore-invalid-headers),
[large_client_header_buffers](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#large-client-header-buffers) e [underscores_in_headers](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#underscores-in-headers),
que estão envolvidas no processamento de campos de cabeçalho de requisição, a
configuração do servidor depende adicionalmente de ter sido atualizada de acordo com a
linha de requisição ou o campo de cabeçalho `Host`.
- Uma resposta de erro é tratada usando a diretiva [error_page](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#error-page) no
servidor que está processando a requisição no momento.
### Servidores virtuais baseados em nome
O Angie primeiro determina qual servidor deve tratar a requisição. Considere uma
configuração simples onde todos os três servidores virtuais escutam na porta 80:
```nginx
server {
listen 80;
server_name example.org www.example.org;
# ...
}
server {
listen 80;
server_name example.net www.example.net;
# ...
}
server {
listen 80;
server_name example.com www.example.com;
# ...
}
```
Nesta configuração, o Angie determina qual servidor deve tratar a
requisição baseando-se apenas no campo de cabeçalho `Host`. Se o valor deste
cabeçalho não corresponder a nenhum nome de servidor ou se a requisição não contiver este
campo de cabeçalho, o Angie roteará a requisição para o servidor padrão desta
porta. Na configuração acima, o servidor padrão é o primeiro — que é
o comportamento padrão do Angie. Também pode ser explicitamente especificado qual
servidor deve ser o padrão usando o parâmetro `default_server` na
diretiva [listen](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#listen):
```nginx
server {
listen 80 default_server;
server_name example.net www.example.net;
# ...
}
```
#### NOTE
Note que o servidor padrão é uma propriedade do socket de escuta, não do
nome do servidor.
### Nomes internacionalizados
Nomes de domínio internacionalizados ([IDNs](https://en.wikipedia.org/wiki/Internationalized_domain_name)) devem ser
especificados usando uma representação ASCII (Punycode) na diretiva [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name):
```nginx
server {
listen 80;
server_name xn--e1afmkfd.xn--80akhbyknj4f; # пример.испытание
# ...
}
```
### Prevenindo requisições com nomes de servidor indefinidos
Se requisições sem o campo de cabeçalho `Host` não devem ser permitidas, um
servidor que simplesmente descarta tais requisições pode ser definido:
```nginx
server {
listen 80;
server_name "";
return 444;
}
```
Nesta configuração, o nome do servidor é definido como uma string vazia, que corresponde
a requisições sem o campo de cabeçalho `Host`. Um código especial não-padrão 444
é então retornado, que fecha a conexão.
### Combinando servidores virtuais baseados em nome e baseados em IP
Vamos examinar uma configuração mais complexa onde alguns servidores virtuais escutam em
endereços diferentes:
```nginx
server {
listen 192.168.1.1:80;
server_name example.org www.example.org;
# ...
}
server {
listen 192.168.1.1:80;
server_name example.net www.example.net;
# ...
}
server {
listen 192.168.1.2:80;
server_name example.com www.example.com;
# ...
}
```
Nesta configuração, o Angie primeiro testa o endereço IP e a porta da
requisição contra as diretivas [listen](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#listen) dos blocos [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server). Em seguida,
testa o campo de cabeçalho `Host` da requisição contra as
entradas [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name) dos blocos [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server) que corresponderam ao endereço
IP e porta. Se o nome do servidor não for encontrado, a requisição será processada
pelo servidor padrão. Por exemplo, uma requisição para `www.example.com`
recebida na porta 192.168.1.1:80 será tratada pelo servidor padrão para essa
porta — ou seja, pelo primeiro servidor — já que `www.example.com` não está definido
para esta porta.
Como mencionado anteriormente, um servidor padrão é uma propriedade da porta de escuta, e
diferentes servidores padrão podem ser definidos para diferentes portas:
```nginx
server {
listen 192.168.1.1:80;
server_name example.org www.example.org;
# ...
}
server {
listen 192.168.1.1:80 default_server;
server_name example.net www.example.net;
# ...
}
server {
listen 192.168.1.2:80 default_server;
server_name example.com www.example.com;
# ...
}
```
### Escolhendo localizações
Considere uma configuração simples de site PHP:
```nginx
server {
listen 80;
server_name example.org www.example.org;
root /data/www;
location / {
index index.html index.php;
}
location ~* \.(gif|jpg|png)$ {
expires 30d;
}
location ~ \.php$ {
fastcgi_pass localhost:9000;
fastcgi_param SCRIPT_FILENAME
$document_root$fastcgi_script_name;
include fastcgi_params;
}
}
```
O Angie primeiro busca pela `location` de prefixo mais específica dada por
strings literais, independentemente da ordem listada. Na configuração acima,
a única localização de prefixo é `location /`, que corresponde a qualquer requisição e
será usada como último recurso. O Angie então verifica localizações definidas por
expressões regulares na ordem em que aparecem no arquivo de configuração. A
primeira expressão correspondente para a busca, e o Angie usará essa
`location`. Se nenhuma expressão regular corresponder a uma requisição, o Angie usará
a `location` de prefixo mais específica encontrada anteriormente.
#### NOTE
Localizações de todos os tipos testam apenas a parte URI da linha de requisição, excluindo
argumentos. Isso ocorre porque argumentos na string de consulta podem ser especificados de
várias maneiras, por exemplo:
- `/index.php?user=john&page=1`
- `/index.php?page=1&user=john`
Além disso, strings de consulta podem conter qualquer número de parâmetros:
- `/index.php?page=1&something+else&user=john`
Agora vamos ver como as requisições seriam processadas na configuração acima:
- A requisição `/logo.gif` é primeiro correspondida pelo prefixo `location
/` e depois pela expressão regular `.(gif|jpg|png)$`. Portanto, é
tratada pela última localização. Usando a diretiva `root /data/www`,
a requisição é mapeada para o arquivo `/data/www/logo.gif`, e o arquivo é
enviado para o cliente.
- A requisição `/index.php` também é inicialmente correspondida pelo prefixo
`location /` e depois pela expressão regular `.(php)$`.
Consequentemente, é tratada pela última localização, e a requisição é passada
para um servidor FastCGI escutando em `localhost:9000`. A
diretiva [fastcgi_param](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-param) define o parâmetro FastCGI
`SCRIPT_FILENAME` como `/data/www/index.php`, e o servidor FastCGI
executa o arquivo. A variável [$document_root](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#v-document-root) é definida com o valor da
diretiva `root`, e a variável [$fastcgi_script_name](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#v-fastcgi-script-name) é
definida com o URI da requisição, ou seja, `/index.php`.
- A requisição `/about.html` é correspondida apenas pelo prefixo `location
/`, então é tratada nesta localização. Usando a diretiva `root
/data/www`, a requisição é mapeada para o arquivo `/data/www/about.html`,
e o arquivo é enviado para o cliente.
Tratar a requisição `/` é mais complexo. Ela é correspondida apenas pelo prefixo
`location /`, então é tratada por esta localização. A diretiva [index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#id1) então
testa a existência de arquivos de índice de acordo com seus parâmetros e a
diretiva `root /data/www`. Se o arquivo `/data/www/index.html` não
existir mas o arquivo `/data/www/index.php` existir, a diretiva executa
um redirecionamento interno para `/index.php`, e o Angie busca as localizações
novamente como se a requisição tivesse sido enviada por um cliente. Como mencionado anteriormente, a
requisição redirecionada será eventualmente tratada pelo servidor FastCGI.
Os exemplos acima mapeiam uma requisição para um arquivo por meio da diretiva
[root](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#root), mas o mapeamento completo envolve várias diretivas atuando em conjunto.
Uma vez selecionada a [location](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#location) correspondente, o Angie mapeia o
[$uri](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#v-uri) normalizado da requisição para um caminho no sistema de
arquivos: a diretiva [root](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#root) acrescenta o URI inteiro ao seu valor, enquanto a
diretiva [alias](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#alias) substitui o prefixo de location correspondido. A diretiva
[try_files](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#try-files) então verifica arquivos candidatos relativos a esse caminho; se
nenhum existir, seu último parâmetro aciona um redirecionamento interno, e o Angie
busca as localizações novamente contra o novo [$uri](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#v-uri), assim como no
redirecionamento de índice acima.
Para a mesma requisição `/images/top.gif`, as duas locations abaixo a
resolvem para o mesmo arquivo, `/data/w3/images/top.gif`:
```nginx
location /images/ {
root /data/w3; # acrescentar: /data/w3 + /images/top.gif
}
location /images/ {
alias /data/w3/images/; # substituir: /images/ -> /data/w3/images/, depois top.gif
}
```
Com [alias](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#alias), o prefixo correspondido é removido pelo seu comprimento, portanto as
barras finais da location e do valor de alias devem ser consistentes. Remover a
barra final do caminho de alias acima resultaria em
`/data/w3/imagestop.gif`.
## Proxy e Balanceamento de Carga
Um uso comum do Angie é configurá-lo como um servidor proxy. Nesta função,
o Angie recebe requisições, encaminha-as para os servidores proxy, recupera
respostas desses servidores e envia as respostas de volta aos clientes.
Um servidor proxy simples:
```nginx
server {
location / {
proxy_pass http://backend:8080;
}
```
A diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) instrui o Angie a passar requisições de clientes para
o backend `backend:8080` (o servidor proxy). Existem muitas
[diretivas](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) adicionais disponíveis para configurar ainda mais uma conexão
proxy.
### Proxy FastCGI
O Angie pode ser usado para rotear requisições para servidores FastCGI que executam aplicações
construídas com vários frameworks e linguagens de programação, como PHP.
A configuração mais básica do Angie para trabalhar com um servidor FastCGI
envolve usar a diretiva [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass) em vez da
diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), juntamente com diretivas [fastcgi_param](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-param) para definir
parâmetros passados para o servidor FastCGI. Suponha que o servidor FastCGI esteja
acessível em `localhost:9000`. Em PHP, o parâmetro `SCRIPT_FILENAME`
é usado para determinar o nome do script, e o parâmetro `QUERY_STRING`
é usado para passar parâmetros de requisição. A configuração resultante seria:
```nginx
server {
location / {
fastcgi_pass localhost:9000;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param QUERY_STRING $query_string;
}
location ~ \.(gif|jpg|png)$ {
root /data/images;
}
}
```
Esta configuração define um servidor que roteia todas as requisições, exceto aquelas para
imagens estáticas, para o servidor proxy operando em `localhost:9000` via o
protocolo FastCGI.
### Proxy WebSocket
Para atualizar uma conexão de HTTP/1.1 para WebSocket, é usado o mecanismo de [troca de protocolo](https://datatracker.ietf.org/doc/html/rfc2616#section-14.42) disponível no HTTP/1.1.
No entanto, há uma sutileza: como o cabeçalho `Upgrade` é um [cabeçalho hop-by-hop](https://datatracker.ietf.org/doc/html/rfc2616#section-13.5.1), ele não é passado do cliente para o servidor com proxy. Com proxy direto, os clientes podem usar o método CONNECT para contornar esse problema. Essa abordagem não funciona com proxy reverso, pois os clientes não têm conhecimento de nenhum servidor proxy, e é necessário processamento especial no servidor proxy.
O Angie implementa um modo especial de operação que permite configurar um túnel entre um cliente e um servidor com proxy se o servidor com proxy retornar uma resposta com código 101 (Switching Protocols), e o cliente solicitar uma troca de protocolo através do cabeçalho `Upgrade` na requisição.
Como mencionado, cabeçalhos hop-by-hop, incluindo `Upgrade` e `Connection`, não são passados do cliente para o servidor com proxy. Portanto, para que o servidor com proxy tenha conhecimento da intenção do cliente de trocar para o protocolo WebSocket, esses cabeçalhos devem ser passados explicitamente:
```nginx
location /chat/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
```
Um exemplo mais sofisticado demonstra como o valor do campo de cabeçalho `Connection` em uma requisição para o servidor com proxy depende da presença do campo `Upgrade` no cabeçalho da requisição do cliente:
```nginx
http {
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
...
location /chat/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
}
}
}
```
Por padrão, a conexão será fechada se o servidor com proxy não transmitir nenhum dado dentro de 60 segundos. Esse timeout pode ser aumentado usando a diretiva [proxy_read_timeout](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-read-timeout). Alternativamente, o servidor com proxy pode ser configurado para enviar periodicamente frames de ping WebSocket para redefinir o timeout e verificar se a conexão ainda está ativa.
### Balanceamento de Carga
O balanceamento de carga entre múltiplas instâncias de aplicação é uma técnica amplamente usada para otimizar a utilização de recursos, maximizar o throughput, reduzir a latência e garantir configurações tolerantes a falhas.
O Angie pode ser usado como um balanceador de carga HTTP altamente eficiente para distribuir tráfego para múltiplos servidores de aplicação, melhorando assim o desempenho, escalabilidade e confiabilidade de aplicações web.
A configuração mais simples para balanceamento de carga com Angie pode parecer assim:
```nginx
http {
upstream myapp1 {
server srv1.example.com;
server srv2.example.com;
server srv3.example.com;
}
server {
listen 80;
location / {
proxy_pass http://myapp1;
}
}
}
```
No exemplo acima, três instâncias da mesma aplicação estão executando em `srv1` até `srv3`. Quando um método de balanceamento de carga não é explicitamente configurado, o padrão é round-robin. Outros mecanismos de balanceamento de carga suportados incluem: [weight](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), [least_conn](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-least-conn) e [ip_hash](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-ip-hash). A implementação de proxy reverso no Angie também suporta verificações de saúde do servidor in-band (ou passivas). Essas são configuradas usando as diretivas [max_fails](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails) e [fail_timeout](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#fail-timeout) dentro do bloco [server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) no contexto [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream).
## Logging
#### NOTE
Além das opções listadas aqui,
você também pode habilitar o [log de depuração](https://pt.angie.software//angie/docs/troubleshooting.md#debug-logging).
### Syslog
As diretivas [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log) e [access_log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log) suportam logging para `syslog`. Os seguintes parâmetros são usados para configurar logging para `syslog`:
| `server=`address | Especifica o endereço de um servidor `syslog`. O endereço pode ser um nome de domínio ou um endereço IP, com uma porta opcional, ou um caminho de socket de domínio UNIX especificado após o prefixo `"unix:"`. Se a porta não for especificada, a porta UDP 514 é usada. Se um nome de domínio resolver para múltiplos endereços IP, o primeiro endereço resolvido é usado. |
|--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `facility=`string | Define a facility para mensagens `syslog`, conforme definido na [RFC 3164](https://datatracker.ietf.org/doc/html/rfc3164.html). As facilities possíveis incluem: `"kern"`, `"user"`, `"mail"`, `"daemon"`, `"auth"`, `"intern"`, `"lpr"`, `"news"`, `"uucp"`, `"clock"`, `"authpriv"`, `"ftp"`, `"ntp"`, `"audit"`, `"alert"`, `"cron"`, `"local0".."local7"`. O padrão é `"local7"`. |
| `severity=`string | Define o nível de severidade das mensagens `syslog` para [access_log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log), conforme especificado na [RFC 3164](https://datatracker.ietf.org/doc/html/rfc3164.html). Os valores possíveis são os mesmos do segundo parâmetro (level) da diretiva [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log). O padrão é `"info"`. A severidade das mensagens de erro é determinada pelo Angie, então este parâmetro é ignorado na diretiva [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log). |
| `tag=`string | Define a tag para mensagens `syslog`. A tag padrão é `"angie"`. |
| `nohostname` | Desabilita a adição do campo `hostname` no cabeçalho da mensagem `syslog`. |
Exemplo de configuração syslog:
```nginx
error_log syslog:server=192.168.1.1 debug;
access_log syslog:server=unix:/var/log/angie.sock,nohostname;
access_log syslog:server=[2001:db8::1]:12345,facility=local7,tag=angie,severity=info combined;
```
# https://pt.angie.software/angie/docs/configuration/modules.md
# Módulos
Este guia descreve os módulos do Angie, tanto nativos quanto de terceiros,
fornece exemplos de configuração, lista suas diretivas e parâmetros,
bem como variáveis integradas.
## Módulo Core
| [Core](https://pt.angie.software//angie/docs/configuration/modules/core.md#core) | Gerenciamento de arquivos de serviço, processos e outros módulos do Angie. |
|------------------------------------------------------------------------------------|------------------------------------------------------------------------------|
## Módulos HTTP
| [HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#http-core) | Funcionalidade principal para processamento de requisições e respostas HTTP, gerenciamento do servidor HTTP, conexões e arquivos estáticos. |
|----------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Access](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) | Controle de acesso baseado em endereços IP e intervalos CIDR. |
| [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) | Obtenção e renovação automática de certificados SSL usando o protocolo ACME para servidores HTTP. |
| [Docker](https://pt.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker) | Atualização dinâmica de grupos de servidores proxy baseada em labels de contêineres Docker. |
| [Addition](https://pt.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition) | Inserção de um trecho especificado antes ou depois do corpo da resposta. |
| [API](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#http-api) | Interface HTTP RESTful para obter informações básicas do servidor web e estatísticas em formato JSON, bem como gerenciar grupos de servidores proxy. |
| [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) | Autenticação HTTP básica para controle de acesso baseado em nome de usuário e senha. |
| [Auth Request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) | Autorização usando uma sub-requisição para um serviço HTTP externo. |
| [AutoIndex](https://pt.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex) | Listagem automática de diretório sem um arquivo de índice. |
| [Browser](https://pt.angie.software//angie/docs/configuration/modules/http/http_browser.md#http-browser) (obsoleto) | Identificação de navegador baseada no cabeçalho `User-Agent`. |
| [Charset](https://pt.angie.software//angie/docs/configuration/modules/http/http_charset.md#http-charset) | Configuração e conversão de codificação de resposta. |
| [DAV](https://pt.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) | Gerenciamento de arquivos no servidor usando o protocolo WebDAV. |
| [DoH](https://pt.angie.software//angie/docs/configuration/modules/http/http_doh.md#http-doh) | Servidor DNS over HTTPS (RFC 8484) que faz proxy de consultas DNS para um grupo de servidores DNS via UDP ou TCP. |
| [Empty GIF](https://pt.angie.software//angie/docs/configuration/modules/http/http_empty_gif.md#http-empty-gif) | Servindo um GIF transparente de um pixel. |
| [FastCGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#http-fastcgi) | Proxy de requisições para um servidor FastCGI. |
| [FLV](https://pt.angie.software//angie/docs/configuration/modules/http/http_flv.md#http-flv) | Pseudo-streaming de arquivos Flash Video (FLV). |
| [Geo](https://pt.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo) | Conversão de endereços IP em valores de variáveis especificados. |
| [GeoIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_geoip.md#http-geoip) | Obtenção de dados de endereços IP baseada em geolocalização usando bancos de dados MaxMind GeoIP. |
| [gRPC](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#http-grpc) | Proxy de requisições para um servidor gRPC. |
| [GunZIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_gunzip.md#http-gunzip) | Descompressão de respostas comprimidas com GZip para modificação e em casos onde o cliente não suporta compressão. |
| [GZip](https://pt.angie.software//angie/docs/configuration/modules/http/http_gzip.md#http-gzip) | Compressão de respostas usando o método GZip para economizar tráfego. |
| [GZip Static](https://pt.angie.software//angie/docs/configuration/modules/http/http_gzip_static.md#http-gzip-static) | Servindo arquivos estáticos pré-comprimidos usando o método GZip. |
| [Headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_headers.md#http-headers) | Modificação de campos de cabeçalho de resposta. |
| [HTTP2](https://pt.angie.software//angie/docs/configuration/modules/http/http_v2.md#http-v2) | Processamento de requisições usando o protocolo HTTP/2. |
| [HTTP3](https://pt.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) | Processamento de requisições usando o protocolo HTTP/3. |
| [Image Filter](https://pt.angie.software//angie/docs/configuration/modules/http/http_image_filter.md#http-image-filter) [1](#id5) | Transformação de imagens. |
| [Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) | Configuração de arquivos de índice que atendem requisições terminadas com barra (`/`). |
| [Limit Conn](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn) | Limitação do número de requisições concorrentes (conexões ativas) para proteção contra sobrecarga. |
| [Limit Req](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) | Limitação de frequência de requisições para proteção contra sobrecarga e tentativas de adivinhação de senha. |
| [Log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#http-log) | Configuração de logs de requisição para rastreamento de acesso a recursos para fins de monitoramento e análise. |
| [Map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#http-map) | Conversão de variáveis baseada em pares chave-valor predefinidos. |
| [Metric](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#http-metric) | Métricas numéricas personalizadas na API de estatísticas em tempo real. |
| [Memcached](https://pt.angie.software//angie/docs/configuration/modules/http/http_memcached.md#http-memcached) | Recuperação de respostas de um servidor Memcached. |
| [Mirror](https://pt.angie.software//angie/docs/configuration/modules/http/http_mirror.md#http-mirror) | Espelhamento de requisições para outros servidores. |
| [MP4](https://pt.angie.software//angie/docs/configuration/modules/http/http_mp4.md#http-mp4) | Pseudo-streaming de arquivos MP4. |
| [Perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl) [1](#id5) | Manipuladores para estender funcionalidade especificando lógica adicional na linguagem Perl. |
| [Prometheus](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus) | Métricas do servidor em formato compatível com Prometheus para monitoramento e coleta de estatísticas. |
| [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) | Proxy reverso de requisições para outros servidores HTTP. |
| [Random Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) | Seleção aleatória de um arquivo de índice para requisições terminadas com barra (`/`). |
| [RealIP](https://pt.angie.software//angie/docs/configuration/modules/http/http_realip.md#http-realip) | Determinação de endereço e porta do cliente ao operar atrás de outro servidor proxy. |
| [Referer](https://pt.angie.software//angie/docs/configuration/modules/http/http_referer.md#http-referer) | Validação de valores do cabeçalho `Referer`. |
| [Rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#http-rewrite) | Modificação de URI de requisição, redirecionamentos, definição de variáveis, e seleção de configuração condicional. |
| [SCGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#http-scgi) | Proxy de requisições para um servidor SCGI. |
| [Secure Link](https://pt.angie.software//angie/docs/configuration/modules/http/http_secure_link.md#http-secure-link) | Criação de links seguros com capacidade de limitar tempo de acesso. |
| [Slice](https://pt.angie.software//angie/docs/configuration/modules/http/http_slice.md#http-slice) | Divisão de requisições em múltiplas sub-requisições para fragmentos individuais para melhor cache de respostas grandes. |
| [Split Clients](https://pt.angie.software//angie/docs/configuration/modules/http/http_split_clients.md#http-split-clients) | Criação de variáveis para testes A/B, releases canário, sharding, e outros cenários que requerem divisão proporcional de grupos. |
| [SSI](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi) | Processamento de comandos SSI (Server Side Includes) em respostas. |
| [SSL](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#http-ssl) | Configuração SSL/TLS para processamento de requisições HTTPS. |
| [Stub Status](https://pt.angie.software//angie/docs/configuration/modules/http/http_stub_status.md#http-stub-status) (obsoleto) | Contadores globais de conexão e requisição em formato texto. |
| [Sub](https://pt.angie.software//angie/docs/configuration/modules/http/http_sub.md#http-sub) | Busca e substituição de fragmentos no corpo da resposta. |
| [Tunnel](https://pt.angie.software//angie/docs/configuration/modules/http/http_tunnel.md#http-tunnel) | Gerenciamento de requisições HTTP/1.1 CONNECT e estabelecimento de túneis de ponta a ponta. |
| [Upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream) | Configuração de grupos de servidores proxy para balanceamento de carga. |
| [Upstream Probe](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#http-upstream-probe) | Configuração de verificações ativas de saúde para grupos de servidores proxy. |
| [UserID](https://pt.angie.software//angie/docs/configuration/modules/http/http_userid.md#http-userid) | Emissão e processamento de cookies com identificadores únicos de cliente para rastreamento de sessão e análise. |
| [uWSGI](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#http-uwsgi) | Proxy de requisições para um servidor uWSGI. |
| [XSLT](https://pt.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt) [1](#id5) | Transformação de documentos XML usando a linguagem XSLT. |
## Módulos Stream
| [Stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) | Funcionalidade principal do servidor stream para balanceamento de protocolos TCP e UDP no nível L4. |
|-------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| [Access](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_access.md#stream-access) | Controle de acesso baseado em endereços IP e intervalos CIDR. |
| [ACME](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme) | Obtenção e renovação automática de certificados SSL usando o protocolo ACME para servidores stream. |
| [Geo](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_geo.md#stream-geo) | Conversão de endereços IP em valores de variáveis especificados. |
| [GeoIP](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_geoip.md#stream-geoip) | Obtenção de dados de endereços IP baseada em geolocalização usando bancos de dados MaxMind GeoIP. |
| [Limit Conn](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn) | Limitação do número de conexões concorrentes para proteção contra sobrecarga. |
| [Log](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_log.md#stream-log) | Configuração de logs de sessão para rastreamento de acesso a recursos para fins de monitoramento e análise. |
| [Map](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_map.md#stream-map) | Conversão de variáveis baseada em pares chave-valor predefinidos. |
| [Metric](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#stream-metric) | Métricas numéricas personalizadas na API de estatísticas em tempo real. |
| [MQTT Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_mqtt_preread.md#stream-mqtt-preread) | Leitura de identificador de cliente e nome de usuário de conexões MQTT antes de tomar decisões de balanceamento de carga. |
| [Pass](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_pass.md#stream-pass) | Passagem de conexões aceitas diretamente para um socket de escuta configurado. |
| [Proxy](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#stream-proxy) | Configuração de proxy para outros servidores. |
| [RDP Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_rdp_preread.md#stream-rdp-preread) | Leitura de cookies de conexões RDP antes de tomar decisões de balanceamento de carga. |
| [RealIP](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_realip.md#stream-realip) | Determinação de endereço e porta do cliente ao operar atrás de outro servidor proxy. |
| [Return](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_return.md#stream-return) | Envio de um valor especificado ao cliente na conexão sem proxy adicional. |
| [Set](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_set.md#stream-set) | Definição de valores de variáveis especificados. |
| [Split Clients](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_split_clients.md#stream-split-clients) | Criação de variáveis para testes A/B, releases canário, sharding, e outros cenários que requerem divisão proporcional de grupos. |
| [SSL](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#stream-ssl) | Terminação de protocolos SSL/TLS e DTLS. |
| [SSL Preread](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl_preread.md#stream-ssl-preread) | Extração de informações de mensagens `ClientHello` sem terminação SSL/TLS e antes de tomar decisões de balanceamento de carga. |
| [Upstream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#stream-upstream) | Configuração de grupos de servidores proxy para balanceamento de carga. |
| [Upstream Probe](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#stream-upstream-probe) | Configuração de verificações ativas de saúde para grupos de servidores proxy. |
## Módulos Mail
| [Mail](https://pt.angie.software//angie/docs/configuration/modules/mail/index.md#mail-core) | Funcionalidade principal do servidor proxy de email. |
|----------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
| [Auth HTTP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_auth_http.md#mail-auth-http) | Autenticação de usuário e seleção de servidor para proxy subsequente usando requisições HTTP para um servidor externo. |
| [IMAP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_imap.md#mail-imap) | Suporte ao protocolo IMAP. |
| [POP3](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_pop3.md#mail-pop3) | Suporte ao protocolo POP3. |
| [Proxy](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_proxy.md#mail-proxy) | Configuração de proxy para outros servidores. |
| [RealIP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_realip.md#mail-realip) | Determinação de endereço e porta do cliente ao operar atrás de outro servidor proxy. |
| [SMTP](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_smtp.md#mail-smtp) | Suporte ao protocolo SMTP. |
| [SSL](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#mail-ssl) | Suporte aos protocolos SSL/TLS e StartTLS. |
## Módulo Google PerfTools
| [Google PerfTools](https://pt.angie.software//angie/docs/configuration/modules/google_perftools.md#google-perftools) | Responsável pela integração com a biblioteca Google Performance Tools para profiling de aplicações e análise de desempenho. |
|------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|
## Módulos WASM
| [WASM](https://pt.angie.software//angie/docs/configuration/modules/wasm/index.md#wasm-core) [1](#id5) | Funcionalidade principal WASM habilitando execução de código WASM no Angie. |
|--------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|
| [WAMR](https://pt.angie.software//angie/docs/configuration/modules/wasm/wasm_wamr.md#wasm-wamr) | Integração com [WebAssembly Micro Runtime](https://github.com/bytecodealliance/wasm-micro-runtime). |
| [Wasmtime](https://pt.angie.software//angie/docs/configuration/modules/wasm/wasm_wasmtime.md#wasm-wasmtime) | Integração com o ambiente de execução [Wasmtime](https://wasmtime.dev/). |
## Módulos de terceiros
Módulos de terceiros compatíveis com nginx para os quais criamos pacotes.
Sua instalação é descrita na seção [Módulos de Terceiros](https://pt.angie.software//angie/docs/installation/external-modules/index.md#install-thirdpartymodules),
e a lista completa com descrições está na seção [Módulos de Terceiros](https://pt.angie.software//angie/docs/configuration/modules/external-modules/index.md#list-of-modules).
### Notas de rodapé
* **[1]** Em nossas builds, esses módulos são compilados dinamicamente e instalados como [pacotes separados](https://pt.angie.software//angie/docs/installation/index.md#install-packages); para detalhes, veja a descrição de cada módulo.
# https://pt.angie.software/angie/docs/configuration/modules/core.md
# Módulo Core
O módulo fornece funcionalidade essencial e diretivas de configuração
necessárias para a operação básica do servidor,
e lida com tarefas críticas como gerenciar processos worker,
configurar modelos orientados a eventos,
e processar conexões e requisições recebidas.
Inclui diretivas essenciais para configurar o processo principal, log
de erros, e controlar o comportamento do servidor em baixo nível.
## Exemplo de Configuração
```nginx
user www www;
worker_processes 2;
error_log /var/log/error.log info;
events {
use kqueue; worker_connections 2048;
}
```
## Diretivas
### accept_mutex
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `accept_mutex` `on` | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `accept_mutex off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Quando `accept_mutex` está habilitado,
processos worker aceitarão novas conexões alternadamente.
Sem essa configuração, todos os processos worker são notificados de novas conexões,
o que pode levar ao uso ineficiente de recursos do sistema
se o volume de novas conexões for baixo.
#### NOTE
Não há necessidade de habilitar `accept_mutex` em sistemas
que suportam a flag `EPOLLEXCLUSIVE`
ou ao usar a diretiva [reuseport](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#listen).
### accept_mutex_delay
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `accept_mutex_delay` time; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | `accept_mutex_delay 500ms;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Se [accept_mutex](#accept-mutex) estiver habilitado,
esta diretiva especifica o tempo máximo
que um processo worker aguardará
para continuar aceitando novas conexões
enquanto outro processo worker já está lidando com novas conexões.
### daemon
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `daemon` `on` | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | `daemon on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Determina se o Angie deve executar como daemon.
Isso é usado principalmente durante o desenvolvimento.
### debug_connection
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `debug_connection` address | CIDR | `unix:`; |
|-------------------------------------------------------------------------------------------|------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Habilita logs de depuração para conexões específicas de clientes.
Outras conexões usarão o nível de logging
definido pela diretiva [error_log](#error-log).
Você pode especificar conexões por endereço IPv4 ou IPv6, rede, ou hostname.
Para conexões usando sockets de domínio UNIX,
use o parâmetro `unix:` para habilitar logs de depuração.
```nginx
events {
debug_connection 127.0.0.1;
debug_connection localhost;
debug_connection 192.0.2.0/24;
debug_connection ::1;
debug_connection 2001:0db8::/32;
debug_connection unix:;
# ...
}
```
#### NOTE
Para que esta diretiva funcione,
o Angie deve ser compilado com [log de depuração](https://pt.angie.software//angie/docs/troubleshooting.md#debug-logging) habilitado.
### debug_points
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `debug_points` `abort` | `stop`; |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Esta diretiva é usada para depuração.
Quando ocorre um erro interno,
como vazamento de socket durante reinicializações de processos worker,
habilitar `debug_points` criará um arquivo core (`abort`)
ou parará o processo (`stop`) para análise posterior com um depurador do sistema.
### env
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `env` variable[=value]; |
|-------------------------------------------------------------------------------------------|---------------------------|
| Padrão | `env TZ;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Por padrão,
o Angie remove todas as variáveis de ambiente herdadas de seu processo pai
exceto a variável `TZ`.
Esta diretiva permite preservar algumas variáveis herdadas,
modificar seus valores, ou criar novas variáveis de ambiente.
Essas variáveis são então:
- herdadas durante uma
[atualização ao vivo de um arquivo executável](https://pt.angie.software//angie/docs/configuration/runtime.md#service-upgrade)
- usadas pelo módulo [Perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl)
- disponíveis para processos worker
Note que controlar bibliotecas do sistema desta forma nem sempre pode ser efetivo,
pois bibliotecas frequentemente verificam variáveis apenas durante a inicialização,
que ocorre antes desta diretiva fazer efeito.
A variável `TZ` é sempre herdada
e acessível ao módulo [Perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl)
a menos que explicitamente configurado de outra forma.
Exemplo:
```nginx
env MALLOC_OPTIONS;
env PERL5LIB=/data/site/modules;
env OPENSSL_ALLOW_PROXY_CERTS=1;
```
#### NOTE
A variável de ambiente `ANGIE` é usada internamente pelo Angie
e não deve ser definida diretamente pelo usuário.
### error_log
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_log` file [level]; |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `error_log logs/error.log error;` (o caminho depende da [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths) `--error-log-path`) |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main, http, mail, stream, server, location |
Configura o logging,
permitindo que múltiplos logs sejam especificados no mesmo nível de configuração.
Se um arquivo de log não for explicitamente definido no nível de configuração `main`,
o arquivo padrão será usado.
O primeiro parâmetro especifica o arquivo para armazenar o log.
O valor especial `stderr` seleciona o fluxo de erro padrão.
Para configurar logging para [syslog](https://pt.angie.software//angie/docs/configuration/processing.md#syslog-logging),
use o prefixo `"syslog:"`.
Para fazer log para um [buffer de memória cíclico](https://pt.angie.software//angie/docs/troubleshooting.md#cyclic-memory-buffer),
use o prefixo `"memory:"` seguido do tamanho do buffer;
isso é tipicamente usado para depuração.
O segundo parâmetro define o nível de logging, que pode ser um dos seguintes:
`debug`, `info`, `notice`, `warn`, `error`,
`crit`, `alert`, ou `emerg`.
Esses níveis são listados em ordem de severidade crescente.
Definir um nível de log capturará mensagens de severidade igual e superior:
| Configuração | Níveis Capturados |
|----------------|--------------------------------------------------------------------------|
| `debug` | `debug`, `info`, `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `info` | `info`, `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `notice` | `notice`, `warn`, `error`, `crit`, `alert`, `emerg` |
| `warn` | `warn`, `error`, `crit`, `alert`, `emerg` |
| `error` | `error`, `crit`, `alert`, `emerg` |
| `crit` | `crit`, `alert`, `emerg` |
| `alert` | `alert`, `emerg` |
| `emerg` | `emerg` |
Se este parâmetro for omitido,
`error` é usado como nível de logging padrão.
#### NOTE
Para que o nível de logging `debug` funcione,
o Angie deve ser compilado com [log de depuração](https://pt.angie.software//angie/docs/troubleshooting.md#debug-logging) habilitado.
Cada entrada no log de erros tem o seguinte formato:
```text
timestamp [level] PID#TID: *connection_id message
```
Onde:
- `timestamp` — data e hora do evento
- `level` — nível de logging do evento
- `PID#TID` — identificadores de processo e thread
- `*connection_id` — número serial da conexão, compartilhado por todas as requisições da mesma conexão (se aplicável)
- `message` — texto da mensagem de erro ou evento
### events
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `events` { ... }; |
|-------------------------------------------------------------------------------------------|---------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Fornece o contexto do arquivo de configuração para diretivas
que afetam o processamento de conexões.
### include
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `include` file | mask; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | any |
Inclui outro arquivo, ou arquivos que correspondem à mask especificada,
na configuração.
Os arquivos incluídos devem conter diretivas e blocos sintaticamente corretos.
Exemplo:
```nginx
include mime.types;
include vhosts/*.conf;
```
### load_module
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `load_module` arquivo; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Carrega um módulo dinâmico do arquivo especificado.
Se um caminho relativo for fornecido, ele é interpretado com base na
`--prefix` [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure). Para verificar o caminho:
```console
$ sudo angie -V
```
Exemplo:
```nginx
load_module modules/ngx_mail_module.so;
```
Se um módulo dinâmico foi compilado para uma compilação diferente do Angie, o carregamento falha com um
erro como: "module "..." was built for "..." but you are running "Angie"".
### lock_file
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `lock_file` arquivo; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `lock_file logs/angie.lock;` (o caminho depende da `--lock-path` [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths)) |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
O Angie usa um mecanismo de bloqueio para implementar [accept_mutex](#accept-mutex)
e serializar o acesso à memória compartilhada.
Na maioria dos sistemas, os bloqueios são gerenciados usando operações atômicas,
tornando esta diretiva desnecessária.
Em certos sistemas, no entanto, um mecanismo alternativo de arquivo de bloqueio é usado.
Esta diretiva define um prefixo para nomes de arquivos de bloqueio.
### master_process
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `master_process` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `master_process on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Determina se os processos worker são iniciados.
Esta diretiva é destinada aos desenvolvedores do Angie.
### multi_accept
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `multi_accept` `on` | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `multi_accept off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
| `on` | Um processo worker aceitará todas as novas conexões simultaneamente. |
|--------|------------------------------------------------------------------------|
| `off` | Um processo worker aceitará uma nova conexão por vez. |
#### NOTE
Esta diretiva é ignorada
se o método de processamento de conexão [kqueue](https://pt.angie.software//angie/docs/configuration/processing.md#kqueue) for usado,
pois ele fornece o número de novas conexões prontas para serem aceitas.
### pcre_jit
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `pcre_jit` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão | `pcre_jit off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Habilita ou desabilita a "compilação just-in-time" (PCRE JIT)
para expressões regulares conhecidas no momento da análise da configuração.
O PCRE JIT pode acelerar significativamente o processamento de expressões regulares.
#### NOTE
JIT está disponível nas bibliotecas PCRE a partir da versão 8.20,
desde que sejam compiladas com a opção de configuração `--enable-jit`.
Quando o Angie é compilado com a biblioteca PCRE (`--with-pcre=`),
o suporte JIT é habilitado usando a opção `--with-pcre-jit`.
### pid
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `pid` arquivo | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `pid logs/angie.pid;` (o caminho depende da `--pid-path` [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths)) |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Especifica o arquivo que armazenará o ID do processo principal do Angie.
O arquivo é criado atomicamente, o que garante que seu conteúdo esteja sempre correto.
A configuração `off` desabilita a criação deste arquivo.
#### NOTE
Se a configuração do arquivo for modificada durante a reconfiguração
mas apontar para um link simbólico do arquivo PID anterior,
o arquivo não será recriado.
### ssl_engine
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `ssl_engine` dispositivo; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Especifica o nome do acelerador SSL de hardware.
### ssl_object_cache_inheritable
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `ssl_object_cache_inheritable` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------------|
| Padrão | `ssl_object_cache_inheritable on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Se habilitado, objetos SSL (certificados SSL, chaves secretas, certificados CA confiáveis,
listas CRL) são herdados através de recarregamentos de configuração.
Objetos SSL carregados de arquivos são herdados se seu tempo de modificação e índice
de arquivo não mudaram desde o carregamento de configuração anterior. Chaves secretas
especificadas como `engine:name:id` nunca são herdadas, enquanto chaves secretas
especificadas como `data:value` são sempre herdadas.
Objetos SSL carregados de variáveis não podem ser herdados.
Exemplo:
```nginx
ssl_object_cache_inheritable on;
http {
server {
ssl_certificate example.com.crt;
ssl_certificate_key example.com.key;
}
}
```
### thread_pool
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `thread_pool` nome `threads=`número [`max_queue=`número]; |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------------|
| Padrão | `thread_pool default threads=32 max_queue=65536;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define o nome e parâmetros de um pool de threads
usado para leitura e envio multi-threaded de arquivos
[sem bloquear](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#aio) processos worker.
O parâmetro `threads` define o número de threads no pool.
Se todas as threads no pool estiverem ocupadas executando tarefas, novas tarefas aguardam em uma fila.
O parâmetro `max_queue` limita o número de tarefas
permitidas para aguardar na fila.
Por padrão, até 65536 tarefas podem estar na fila.
Quando a fila transborda, a tarefa é completada com um erro.
### timer_resolution
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `timer_resolution` intervalo; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Reduz a resolução do timer nos processos worker,
reduzindo assim o número de chamadas do sistema `gettimeofday()`.
Por padrão, `gettimeofday()` é chamado cada vez que um evento do kernel é recebido.
Com resolução reduzida, `gettimeofday()` é chamado apenas uma vez por intervalo especificado.
Exemplo:
```nginx
timer_resolution 100ms;
```
A implementação interna do intervalo depende do método usado:
- o filtro `EVFILT_TIMER` se [kqueue](https://pt.angie.software//angie/docs/configuration/processing.md#kqueue) for usado;
- `timer_create()` se [eventport](https://pt.angie.software//angie/docs/configuration/processing.md#eventport) for usado;
- `setitimer()` caso contrário.
### use
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `use` método; |
|-------------------------------------------------------------------------------------------|-----------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Especifica o método a ser usado para [processamento de conexão](https://pt.angie.software//angie/docs/configuration/processing.md#methods-use).
Normalmente não há necessidade de especificá-lo explicitamente,
porque o Angie usará por padrão o método mais eficiente.
### user
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `user` usuário [grupo]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------|
| Padrão | `user ;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define as credenciais de usuário e grupo usadas pelos processos worker
(veja também [parâmetros de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure)).
Se grupo for omitido, um grupo cujo nome é igual ao do usuário é usado.
### worker_aio_requests
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_aio_requests` número; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `worker_aio_requests 32;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Ao usar [aio](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#aio) com o método de processamento de conexão [epoll](https://pt.angie.software//angie/docs/configuration/processing.md#epoll),
define o número máximo de operações de I/O assíncronas pendentes
para um único processo worker.
### worker_connections
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_connections` número; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `worker_connections 512;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | events |
Define o número máximo de conexões simultâneas que podem ser abertas por um processo worker.
Deve-se ter em mente que este número inclui todas as conexões
(por exemplo, conexões com servidores proxy, entre outras),
não apenas conexões com clientes.
Outra consideração é que o número real de conexões simultâneas
não pode exceder o limite atual no número máximo de arquivos abertos,
que pode ser alterado por [worker_rlimit_nofile](#worker-rlimit-nofile).
### worker_cpu_affinity
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_cpu_affinity` cpumask ...;
`worker_cpu_affinity` auto [cpumask]; |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Vincula processos worker aos conjuntos de CPUs.
Cada conjunto de CPU é representado por uma máscara de bits das CPUs permitidas.
Deve haver um conjunto separado definido para cada um dos processos worker.
Por padrão, os processos worker não são vinculados a nenhuma CPU específica.
Por exemplo:
```nginx
worker_processes 4;
worker_cpu_affinity 0001 0010 0100 1000;
```
Esta configuração vincula cada processo worker a uma CPU separada.
Alternativamente:
```nginx
worker_processes 2;
worker_cpu_affinity 0101 1010;
```
Isso vincula o primeiro processo worker à CPU0 e CPU2,
e o segundo processo worker à CPU1 e CPU3.
Esta configuração é adequada para hyper-threading.
O valor especial `auto`
permite vincular processos worker automaticamente às CPUs disponíveis:
```nginx
worker_processes auto;
worker_cpu_affinity auto;
```
O parâmetro opcional mask pode ser usado para limitar as CPUs
disponíveis para vinculação automática:
```nginx
worker_cpu_affinity auto 01010101;
```
#### NOTE
A diretiva está disponível apenas no FreeBSD e Linux.
### worker_priority
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_priority` number; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `worker_priority 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define a prioridade de agendamento para processos worker como é feito
pelo comando **nice**: um number negativo
significa prioridade mais alta.
O intervalo permitido normalmente varia de -20 a 20.
Exemplo:
```nginx
worker_priority -10;
```
### worker_processes
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_processes` number | `auto`; |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão | `worker_processes 1;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define o número de processos worker.
O valor ideal depende de muitos fatores incluindo (mas não limitado a)
o número de núcleos de CPU, o número de discos rígidos que armazenam dados,
e padrão de carga.
Quando há dúvida, defini-lo para o número de núcleos de CPU disponíveis
seria um bom começo (o valor "`auto`" tentará detectá-lo automaticamente).
### worker_rlimit_core
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_rlimit_core` size; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Altera o limite no maior tamanho de um arquivo core (`RLIMIT_CORE`)
para processos worker.
Usado para aumentar o limite sem reiniciar o processo principal.
### worker_rlimit_nofile
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_rlimit_nofile` number; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Altera o limite no número máximo de arquivos abertos (`RLIMIT_NOFILE`)
para processos worker.
Usado para aumentar o limite sem reiniciar o processo principal.
### worker_shutdown_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `worker_shutdown_timeout` time; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Configura um timeout em segundos para um desligamento gracioso de processos worker.
Quando o tempo especificado expira,
o Angie tentará fechar todas as conexões atualmente abertas
para facilitar o desligamento.
O desligamento gracioso é iniciado enviando um [sinal QUIT](https://pt.angie.software//angie/docs/configuration/runtime.md#control-signals) para o processo principal, que instrui os processos worker
a parar de aceitar novas conexões e permite que as conexões existentes sejam concluídas.
Os processos worker continuam a lidar com requisições ativas até que terminem,
e então desligam graciosamente. Se as conexões permanecerem abertas
por mais tempo que `worker_shutdown_timeout`, o Angie fechará forçadamente essas
conexões para completar o desligamento.
Além disso, conexões keep-alive de cliente são fechadas apenas se estiverem
inativas por pelo menos o tempo especificado por [lingering_timeout](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#lingering-timeout).
### working_directory
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `working_directory` directory; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Define o diretório de trabalho atual para um processo worker.
É usado principalmente ao escrever um arquivo core,
caso em que um processo worker deve ter permissão de escrita para o
diretório especificado.
# https://pt.angie.software/angie/docs/configuration/modules/http.md
# Módulo HTTP
O módulo HTTP principal implementa a funcionalidade básica de um servidor HTTP: isso
inclui definir blocos de servidor, configurar locations para roteamento de requisições,
servir arquivos estáticos e controlar acesso, configurar redirecionamentos, suportar
conexões keep-alive e gerenciar cabeçalhos de requisição e resposta.
Os outros módulos nesta seção estendem essa funcionalidade, permitindo que você
configure e otimize flexivelmente o servidor HTTP para vários cenários e
requisitos.
## Diretivas
### absolute_redirect
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `absolute_redirect` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão | `absolute_redirect on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Se desabilitado, redirecionamentos emitidos pelo Angie serão relativos.
Veja também as diretivas [server_name_in_redirect](#server-name-in-redirect) e [port_in_redirect](#port-in-redirect).
### aio
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `aio` `on` | `off` | `threads` [=pool]; |
|-------------------------------------------------------------------------------------------|-------------------------------------------|
| Padrão | `aio off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o uso de I/O de arquivo assíncrono (AIO) no FreeBSD e Linux:
```nginx
location /video/ {
aio on;
output_buffers 1 64k;
}
```
No FreeBSD, AIO pode ser usado a partir do FreeBSD 4.3. Antes do FreeBSD 11.0, AIO pode ser linkado estaticamente no kernel:
```nginx
options VFS_AIO
```
ou carregado dinamicamente como um módulo carregável do kernel:
```nginx
kldload aio
```
No Linux, AIO pode ser usado a partir da versão 2.6.22 do kernel. Além disso, é necessário habilitar [directio](#directio), ou caso contrário a leitura será bloqueante:
```nginx
location /video/ {
aio on;
directio 512;
output_buffers 1 128k;
}
```
No Linux, [directio](#directio) pode ser usado apenas para ler blocos que estão alinhados em limites de 512 bytes (ou 4K para XFS). O final não alinhado do arquivo é lido em modo bloqueante. O mesmo vale para requisições de intervalo de bytes e para requisições FLV que não começam do início de um arquivo: a leitura de dados não alinhados no início e fim de um arquivo será bloqueante.
Quando tanto AIO quanto [sendfile](#sendfile) estão habilitados no Linux, AIO é usado para arquivos que são maiores ou iguais ao tamanho especificado na diretiva [directio](#directio), enquanto [sendfile](#sendfile) é usado para arquivos de tamanhos menores ou quando [directio](#directio) está desabilitado:
```nginx
location /video/ {
sendfile on;
aio on;
directio 8m;
}
```
Finalmente, arquivos podem ser lidos e [enviados](#sendfile) usando multi-threading, sem bloquear um processo worker:
```nginx
location /video/ {
sendfile on;
aio threads;
}
```
Operações de leitura e envio de arquivo são transferidas para threads do [pool](https://pt.angie.software//angie/docs/configuration/modules/core.md#thread-pool) especificado. Se o nome do pool for omitido, o pool com o nome "default" é usado. O nome do pool também pode ser definido com variáveis:
```nginx
aio threads=pool$disk;
```
Usar `aio on` requer compilação com o parâmetro de configuração `--with-file-aio`. Usar `aio threads` requer compilação com o parâmetro `--with-threads`.
Atualmente, multi-threading é compatível apenas com os métodos [epoll](https://pt.angie.software//angie/docs/configuration/processing.md#epoll), [kqueue](https://pt.angie.software//angie/docs/configuration/processing.md#kqueue), e [eventport](https://pt.angie.software//angie/docs/configuration/processing.md#eventport). Envio multi-threaded de arquivos é suportado apenas no Linux.
Veja também a diretiva [sendfile](#sendfile).
### aio_write
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `aio_write` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `aio_write off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Se [aio](#aio) estiver habilitado, especifica se é usado para escrever arquivos. Atualmente, isso funciona apenas quando usando `aio threads` e é limitado a escrever arquivos temporários com dados recebidos de servidores proxy.
### alias
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `alias` path; |
|-------------------------------------------------------------------------------------------|-----------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Define uma substituição para a localização especificada. Por exemplo, com a seguinte configuração:
```nginx
location /i/ {
alias /data/w3/images/;
}
```
na requisição de `/i/top.gif`, o arquivo /data/w3/images/top.gif será enviado.
O valor path pode conter [variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables), exceto [$document_root](#v-document-root) e [$realpath_root](#v-realpath-root).
Se `alias` for usado dentro de uma localização definida com uma expressão regular, então tal expressão regular deve conter capturas e `alias` deve referenciar essas capturas, por exemplo:
```nginx
location ~ ^/users/(.+\.(?:gif|jpe?g|png))$ {
alias /data/w3/images/$1;
}
```
Quando a localização corresponde à última parte do valor da diretiva:
```nginx
location /images/ {
alias /data/w3/images/;
}
```
é melhor usar a diretiva [root](#root) em vez disso:
```nginx
location /images/ {
root /data/w3;
}
```
### auth_delay
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_delay` time; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | `auth_delay 0s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Atrasa o processamento de requisições não autorizadas com código de resposta 401 para prevenir
ataques de temporização quando o acesso é limitado por [senha](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) ou pelo
[resultado de subrequisição](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request).
### auto_redirect
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auto_redirect` [`on` | `off` | `default`]; |
|-------------------------------------------------------------------------------------------|-----------------------------------------------|
| Padrão | `auto_redirect default;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Controla o comportamento de [redirecionamento](#location-redirect)
quando uma localização de prefixo termina com uma barra:
```nginx
location /prefix/ {
auto_redirect on;
}
```
Aqui, uma requisição para `/prefix` causa um redirecionamento para `/prefix/`.
O valor `on` habilita explicitamente o redirecionamento,
enquanto `off` o desabilita.
Quando definido como `default`, o redirecionamento é habilitado apenas
se a localização processa requisições com [api](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#a-api), [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass),
[fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass), [scgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass), [memcached_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_memcached.md#memcached-pass),
ou [grpc_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-pass).
### chunked_transfer_encoding
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `chunked_transfer_encoding` `on` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão | `chunked_transfer_encoding on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite desabilitar a codificação de transferência em chunks no HTTP/1.1. Pode ser útil quando usando um software que falha em suportar codificação em chunks apesar do requisito do padrão.
### client
#### Versionadded
Adicionado na versão 1.10.0.
#### Versionchanged
Alterado na versão 1.10.1.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client` { ... } |
|-------------------------------------------------------------------------------------------|--------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Cria um contexto especial `client` para processar requisições HTTP internas
que o Angie executa por conta própria sem envolvimento de cliente externo.
O contexto `client` isola o tráfego de serviço
de vários módulos do Angie do tráfego de usuário,
permitindo controle adicional sobre ele.
Dentro deste contexto, apenas localizações nomeadas
(com o prefixo `@`) podem ser definidas;
elas não são acessíveis para requisições HTTP externas
e só podem ser chamadas programaticamente através de mecanismos internos do servidor.
O contexto `client` é usado para:
- enviar requisições para a autoridade certificadora no módulo [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme)
via a `location @acme` predefinida,
que pode ser adicionalmente configurada
usando diretivas do módulo [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy);
- requisições para a API Docker no módulo [Docker](https://pt.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker)
via as `location @docker_events` predefinidas
e `@docker_containers`,
que podem ser adicionalmente configuradas
usando diretivas do módulo [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy);
- sondagens de saúde de servidores proxy via [upstream_probe (PRO)](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe);
- modo [sticky learn](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-sticky) com `remote_action`
no módulo [Upstream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#stream-upstream) do stream.
O suporte para múltiplos blocos `client`
permite agrupar configurações comuns para múltiplos blocos `location`
dentro de cada bloco,
o que ajuda a evitar duplicação de configuração.
Diretivas especificadas em cada bloco `client`
são herdadas apenas por blocos `location` explicitamente declarados dentro dele.
Em particular, é por isso que elas não afetam a configuração de outros módulos
que implicitamente usam o bloco `client` para requisições de saída
(por exemplo, [ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme) ou [Docker](https://pt.angie.software//angie/docs/configuration/modules/http/http_docker.md#http-docker)).
Exemplo de uso de múltiplos blocos `client`
com herança de configurações:
```nginx
client {
proxy_set_header Host docker.example.com;
proxy_set_header Authorization "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==";
location @docker_events {
}
location @docker_containers {
}
}
client {
proxy_method GET;
proxy_set_header Host backend.example.com;
proxy_set_header X-Real-IP $remote_addr;
location @health_check {
proxy_pass http://upstream-server/health;
}
}
```
#### NOTE
As mesmas diretivas são permitidas aqui como em blocos `location` regulares,
mas apenas manipuladores de conteúdo
(como [js_content](https://pt.angie.software//angie/docs/configuration/modules/external-modules/http_js.md#js-content) ou [autoindex](https://pt.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#id1))
e manipuladores de variáveis (como [map](https://pt.angie.software//angie/docs/configuration/modules/http/http_map.md#id1)),
bem como diretivas que geram requisições por si mesmas,
como `upstream_probe`, realmente funcionam.
Diretivas que operam em outras
[etapas de processamento de requisição](https://pt.angie.software//angie/docs/configuration/processing.md#http-sessions)
(como [limit_req](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#limit-req), [auth_request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#id1),
[try_files](#try-files), filtros de imagem, XSLT, etc.)
não funcionam aqui.
### client_body_buffer_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_buffer_size` size; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | `client_body_buffer_size 8k|16k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tamanho do buffer para leitura do corpo da requisição do cliente. Se o corpo da requisição for maior que o buffer, todo o corpo ou apenas sua parte é escrito em um [arquivo temporário](#client-body-temp-path). Por padrão, o tamanho do buffer é igual a duas páginas de memória. No x86, outras plataformas de 32 bits e x86-64, isso é 8K. Em outras plataformas de 64 bits, geralmente é 16K.
### client_body_in_file_only
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_in_file_only` `on` | `clean` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------------------|
| Padrão | `client_body_in_file_only off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina se deve salvar todo o corpo da requisição do cliente em um arquivo. Esta diretiva pode ser usada durante depuração, ou ao usar a variável [$request_body_file](#v-request-body-file), ou o método [$r->request_body_file](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#p-r-request-body-file) do módulo [Perl](https://pt.angie.software//angie/docs/configuration/modules/http/http_perl.md#http-perl).
| `on` | arquivos temporários não são removidos após o processamento da requisição |
|---------|-------------------------------------------------------------------------------------------------|
| `clean` | permite que os arquivos temporários deixados após o processamento da requisição sejam removidos |
### client_body_in_single_buffer
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_in_single_buffer` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------------|
| Padrão | `client_body_in_single_buffer off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina se deve salvar todo o corpo da requisição do cliente em um único buffer. A diretiva é recomendada ao usar a variável [$request_body](#v-request-body) para reduzir o número de operações de cópia envolvidas.
### client_body_temp_path
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_temp_path` path [level1 [level2 [level3]]]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `client_body_temp_path client_body_temp;` (o caminho depende da [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths) `--http-client-body-temp-path`) |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um diretório para armazenar arquivos temporários com corpos de requisição do cliente. Até três níveis de hierarquia de subdiretórios podem ser usados sob o diretório especificado. Por exemplo, na seguinte configuração
```nginx
client_body_temp_path /spool/angie/client_temp 1 2;
```
um caminho para um arquivo temporário pode parecer assim:
```nginx
/spool/angie/client_temp/7/45/00000123457
```
### client_body_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_body_timeout` time; |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão | `client_body_timeout 60s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um timeout para leitura do corpo da requisição do cliente. O timeout é definido apenas para um período entre duas operações de leitura sucessivas, não para a transmissão de todo o corpo da requisição. Se um cliente não transmitir nada dentro deste tempo, a requisição é terminada com o erro 408 (Request Time-out).
### client_header_buffer_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_header_buffer_size` size; |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão | `client_header_buffer_size 1k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define o tamanho do buffer para leitura do cabeçalho da requisição do cliente. Para a maioria das requisições, um buffer de 1K bytes é suficiente. No entanto, se uma requisição incluir cookies longos, ou vier de um cliente WAP, pode não caber em 1K. Se uma linha de requisição ou um campo de cabeçalho de requisição não couber neste buffer, então buffers maiores, configurados pela diretiva [large_client_header_buffers](#large-client-header-buffers), são alocados.
Se a diretiva for especificada no nível [server](#server), o valor do servidor padrão pode ser usado. Consulte a seção [Seleção de servidor virtual](https://pt.angie.software//angie/docs/configuration/processing.md#request-processing) para detalhes.
### client_header_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_header_timeout` time; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `client_header_timeout 60s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define um timeout para leitura do cabeçalho da requisição do cliente. Se um cliente não transmitir o cabeçalho inteiro dentro deste tempo, a requisição é terminada com o erro 408 (Request Time-out).
### client_max_body_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `client_max_body_size` size; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `client_max_body_size 1m;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tamanho máximo permitido do corpo da requisição do cliente. Se o tamanho em uma requisição exceder o valor configurado, o erro 413 (Request Entity Too Large) é retornado ao cliente. Esteja ciente de que os navegadores não conseguem exibir corretamente este erro.
| `0` | desabilita a verificação do tamanho do corpo da requisição do cliente |
|-------|-------------------------------------------------------------------------|
### connection_pool_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `connection_pool_size` size; |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão | `connection_pool_size 256` | `512;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite ajuste preciso das alocações de memória por conexão. Esta diretiva tem impacto mínimo no desempenho e geralmente não deve ser usada. Por padrão:
| `256` (bytes) | em plataformas de 32 bits |
|-----------------|-----------------------------|
| `512` (bytes) | em plataformas de 64 bits |
### default_type
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `default_type` mime-type; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `default_type text/plain;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tipo MIME padrão de uma resposta. O mapeamento de extensões de nome de arquivo para tipos MIME pode ser definido com a diretiva [types](#types).
### directio
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `directio` size | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão | `directio off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita o uso da flag `O_DIRECT` (FreeBSD, Linux), da flag `F_NOCACHE` (macOS), ou da função `directio()` (Solaris), ao ler arquivos que são maiores ou iguais ao tamanho especificado. A diretiva desabilita automaticamente o uso de [sendfile](#sendfile) para uma determinada requisição. É recomendada para servir arquivos grandes:
```nginx
directio 4m;
```
ou ao usar [aio](#aio) no Linux.
### directio_alignment
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `directio_alignment` size; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | `directio_alignment 512;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o alinhamento para [directio](#directio). Na maioria dos casos, um alinhamento de 512 bytes é suficiente. No entanto, ao usar XFS no Linux, ele precisa ser aumentado para 4K.
### disable_symlinks
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `disable_symlinks` `off`;
`disable_symlinks` `on` | `if_not_owner` [`from=`part]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------|
| Padrão | `disable_symlinks off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Determina como os links simbólicos devem ser tratados ao abrir arquivos:
| `off` | Links simbólicos no caminho são permitidos e não verificados. Este é o comportamento padrão. |
|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `on` | Se qualquer componente do caminho for um link simbólico, o acesso ao arquivo é negado. |
| `if_not_owner` | O acesso ao arquivo é negado se qualquer componente do caminho for um link simbólico, e o link e o objeto para o qual ele aponta tiverem proprietários diferentes. |
| `from=`part | Ao verificar links simbólicos (parâmetros `on` e `if_not_owner`), todos os componentes do caminho são geralmente verificados. É possível pular a verificação de links simbólicos na parte inicial do caminho especificando adicionalmente o parâmetro `from=part`. Neste caso, links simbólicos são verificados apenas a partir do componente do caminho que segue a parte inicial especificada. Se o valor não for uma parte inicial do caminho verificado, o caminho é verificado inteiramente, como se este parâmetro não tivesse sido especificado. Se o valor corresponder completamente ao nome do arquivo, links simbólicos não são verificados. Variáveis podem ser usadas no valor do parâmetro. |
Exemplo:
```nginx
disable_symlinks on from=$document_root;
```
Esta diretiva está disponível apenas em sistemas que possuem as interfaces `openat()` e `fstatat()`. Tais sistemas incluem versões modernas do FreeBSD, Linux e Solaris.
#### WARNING
Os parâmetros `on` e `if_not_owner` adicionam sobrecarga de processamento.
Em sistemas que não suportam abrir diretórios apenas para busca, usar estes parâmetros requer que os processos worker tenham permissões de leitura para todos os diretórios sendo verificados.
#### NOTE
Os módulos [AutoIndex](https://pt.angie.software//angie/docs/configuration/modules/http/http_autoindex.md#http-autoindex), [Random Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_random_index.md#http-random-index) e [DAV](https://pt.angie.software//angie/docs/configuration/modules/http/http_dav.md#http-dav) atualmente ignoram esta diretiva.
### early_hints
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `early_hints` string ...; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define condições sob as quais a resposta "103 Early Hints" será passada para um cliente. A resposta pode ser retornada por backends proxy e gRPC. Se pelo menos um valor dos parâmetros string não for vazio e não for igual a `0`, a resposta será passada:
```nginx
map $http_sec_fetch_mode $early_hints {
navigate $http2$http3;
}
server {
...
location / {
early_hints $early_hints;
proxy_pass http://example.com;
}
}
```
Os valores dos parâmetros podem conter variáveis.
### error_log_user_tag
#### Versionadded
Adicionado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_log_user_tag` value; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Adiciona uma tag específica da requisição aos registros de [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log). O value pode
[conter variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables). A diretiva pode ser especificada
várias vezes para adicionar várias tags. As tags podem corresponder a
`filter=tag:` em [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log).
### error_page
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `error_page` code ... [=[response]] uri; |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define a URI que será mostrada para os erros especificados. O valor uri pode usar variáveis.
Exemplo:
```nginx
error_page 404 /404.html;
error_page 500 502 503 504 /50x.html;
```
Isso causa um redirecionamento interno para a uri especificada com o método da requisição do cliente alterado para "GET" (para todos os métodos exceto "GET" e "HEAD").
Além disso, é possível alterar o código de resposta para outro usando a sintaxe como `=response`, por exemplo:
```nginx
error_page 404 =200 /empty.gif;
```
Se uma resposta de erro é processada por um servidor proxy ou um servidor FastCGI/uwsgi/SCGI/gRPC, e o servidor pode retornar diferentes códigos de resposta (por exemplo, 200, 302, 401, ou 404), é possível passar o código que ele retorna:
```nginx
error_page 404 = /404.php;
```
Se não há necessidade de alterar o URI e método durante o redirecionamento interno, é possível passar o processamento de erro para um `location` nomeado:
```nginx
location / {
error_page 404 = @fallback;
}
location @fallback {
proxy_pass http://backend;
}
```
#### NOTE
Se um erro ocorre durante o processamento do uri, a resposta com o código do último erro ocorrido é retornada ao cliente.
Também é possível usar redirecionamentos de URL para processamento de erro:
```nginx
error_page 403 http://example.com/forbidden.html;
error_page 404 =301 http://example.com/notfound.html;
```
Neste caso, por padrão, o código de resposta 302 é retornado ao cliente. Ele só pode ser alterado para um dos códigos de resposta de redirecionamento (301, 302, 303, 307, e 308).
### etag
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `etag` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | `etag on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a geração automática do campo de cabeçalho de resposta `ETag` para recursos estáticos.
### http
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `http` { ... } |
|-------------------------------------------------------------------------------------------|------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | main |
Fornece o contexto do arquivo de configuração no qual as diretivas do servidor HTTP são especificadas.
### if_modified_since
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `if_modified_since` `off` | `exact` | `before`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------------|
| Padrão | `if_modified_since exact;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Especifica como comparar o tempo de modificação de uma resposta com o tempo no campo de cabeçalho de requisição `If-Modified-Since`:
| `off` | a resposta é sempre considerada modificada |
|----------|----------------------------------------------------------------------------------------------------------------------|
| `exact` | correspondência exata |
| `before` | o tempo de modificação da resposta é menor ou igual ao tempo no campo de cabeçalho de requisição `If-Modified-Since` |
### ignore_invalid_headers
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `ignore_invalid_headers` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão | `ignore_invalid_headers on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Controla se o Angie ignora campos de cabeçalho com nomes inválidos. Nomes válidos são compostos de letras inglesas, dígitos, hífens, e possivelmente sublinhados (conforme controlado pela diretiva [underscores_in_headers](#underscores-in-headers)).
Se a diretiva é especificada no nível [server](#server), o valor do servidor padrão pode ser usado.
### internal
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `internal;` |
|-------------------------------------------------------------------------------------------|---------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Especifica que um determinado `location` pode ser usado apenas para requisições internas. Para requisições externas, o erro de cliente 404 (Not Found) é retornado. Requisições internas são as seguintes:
* requisições redirecionadas pelas diretivas [error_page](#error-page), [index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#id1), [random_index](https://pt.angie.software//angie/docs/configuration/modules/http/http_random_index.md#id1) e [try_files](#try-files);
* requisições redirecionadas pelo campo de cabeçalho de resposta `X-Accel-Redirect` de um servidor upstream;
* sub-requisições formadas pelo comando `include virtual` do módulo [SSI](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssi.md#http-ssi), pelas diretivas do módulo [Addition](https://pt.angie.software//angie/docs/configuration/modules/http/http_addition.md#http-addition), e pelas diretivas [auth_request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#id1) e [mirror](https://pt.angie.software//angie/docs/configuration/modules/http/http_mirror.md#id1);
* requisições alteradas pela diretiva [rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5);
* requisições redirecionadas pela diretiva [goto](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#goto).
Exemplo:
```nginx
error_page 404 /404.html;
location = /404.html {
internal;
}
```
Como o erro 404 é retornado no contexto de um `location` com a diretiva `internal`, requisições externas podem ser redirecionadas para um location diferente. Isso permite usar o mesmo prefixo para requisições externas e internas, mas com processamento diferente, por exemplo:
```nginx
location /path {
internal;
error_page 404 =@external;
proxy_pass https://internal;
}
location @external {
proxy_pass https://external;
}
```
Aqui, uma requisição externa `GET /path` será enviada por proxy para
`https://external/path`, enquanto a mesma requisição interna será enviada por proxy para
`https://internal/path`.
#### NOTE
Para prevenir loops que podem ocorrer com configurações incorretas, o número de redirecionamentos internos é limitado a dez. Quando este limite é atingido, o erro 500 (Internal Server Error) é retornado. Em tais casos, a mensagem `rewrite or internal redirection cycle` pode ser vista no log de erro.
### keepalive_disable
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_disable` `none` | browser ...; |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão | `keepalive_disable msie6;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Desabilita conexões keep-alive com navegadores com comportamento inadequado. Os parâmetros browser especificam quais navegadores serão afetados.
| `none` | habilita conexões keep-alive com todos os navegadores |
|----------|---------------------------------------------------------------------------------------------------------------------------------|
| `msie6` | desabilita conexões keep-alive com versões antigas do MSIE, uma vez que uma requisição POST seja recebida |
| `safari` | desabilita conexões keep-alive com Safari e navegadores similares ao Safari no macOS e sistemas operacionais similares ao macOS |
### keepalive_requests
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_requests` number; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `keepalive_requests 1000;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o número máximo de requisições que podem ser atendidas através de uma conexão keep-alive. Após o número máximo de requisições ser feito, a conexão é fechada.
O fechamento periódico de conexões é necessário para liberar alocações de memória por conexão. Portanto, usar um número máximo muito alto de requisições pode resultar em uso excessivo de memória e não é recomendado.
### keepalive_time
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_time` time; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | `keepalive_time 1h;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita o tempo máximo durante o qual requisições podem ser processadas através de uma conexão keep-alive. Após este tempo ser atingido, a conexão é fechada seguindo o processamento da requisição subsequente.
### keepalive_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `keepalive_timeout` timeout [header_timeout]; |
|-------------------------------------------------------------------------------------------|-------------------------------------------------|
| Padrão | `keepalive_timeout 75s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
| timeout | define um timeout durante o qual uma conexão keep-alive do cliente permanecerá aberta no lado do servidor |
|-----------|-------------------------------------------------------------------------------------------------------------|
| `0` | desabilita conexões keep-alive do cliente |
O segundo parâmetro, *opcional*, define um valor no campo de cabeçalho `Keep‑Alive: timeout=time` na resposta. Os dois parâmetros podem diferir.
O campo de cabeçalho `Keep-Alive: timeout=time` é reconhecido pelo Mozilla e Konqueror. O MSIE fecha conexões keep-alive por si só em cerca de 60 segundos.
### large_client_header_buffers
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `large_client_header_buffers` number size; |
|-------------------------------------------------------------------------------------------|----------------------------------------------|
| Padrão | `large_client_header_buffers 4 8k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define o número máximo e o tamanho dos buffers usados para ler cabeçalhos de requisição grandes do cliente. Uma linha de requisição não pode exceder o tamanho de um buffer, ou o erro 414 (Request-URI Too Large) é retornado ao cliente. Um campo de cabeçalho de requisição também não pode exceder o tamanho de um buffer, ou o erro 400 (Bad Request) é retornado ao cliente. Os buffers são alocados apenas sob demanda. Por padrão, o tamanho do buffer é igual a 8K bytes. Se após o fim do processamento da requisição uma conexão é transicionada para o estado keep-alive, esses buffers são liberados.
Se a diretiva for especificada no nível [server](#server), o valor do servidor padrão pode ser usado.
### limit_except
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_except` method1 [method2...] { ... }; |
|-------------------------------------------------------------------------------------------|------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Limita os métodos HTTP permitidos dentro de uma localização. O parâmetro method pode ser um dos
seguintes: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`,
`MKCOL`, `COPY`, `MOVE`, `OPTIONS`, `PROPFIND`,
`PROPPATCH`, `LOCK`, `UNLOCK`, ou `PATCH`. Permitir o
método `GET` também torna o método `HEAD` permitido. O acesso a outros métodos
pode ser limitado usando as diretivas dos módulos [Access](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) e
[Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic):
```nginx
limit_except GET {
allow 192.168.1.0/32;
deny all;
}
```
#### NOTE
A restrição neste exemplo se aplica a todos os métodos
**exceto** `GET` e `HEAD`.
### limit_rate
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_rate` rate; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `limit_rate 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Limita a taxa de transmissão de resposta para um cliente. A taxa é especificada em bytes por segundo. O valor zero desabilita a limitação de taxa. O limite é definido por requisição, e assim se um cliente abrir simultaneamente duas conexões, a taxa geral será duas vezes maior que o limite especificado.
O valor do parâmetro pode conter variáveis. Pode ser útil em casos onde a taxa deve ser limitada dependendo de uma determinada condição:
```nginx
map $slow $rate {
1 4k;
2 8k;
}
limit_rate $rate;
```
O limite de taxa também pode ser definido na variável [$limit_rate](#v-limit-rate), no entanto, este método não é recomendado:
```nginx
server {
if ($slow) {
set $limit_rate 4k;
}
}
```
O limite de taxa também pode ser definido no campo de cabeçalho `X-Accel-Limit-Rate` de uma resposta de servidor proxy. Esta capacidade pode ser desabilitada usando as diretivas [proxy_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ignore-headers), [fastcgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-ignore-headers), [uwsgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-ignore-headers), e [scgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-ignore-headers).
### limit_rate_after
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `limit_rate_after` size; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `limit_rate_after 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define a quantidade inicial após a qual a transmissão adicional de uma resposta para um cliente será limitada por taxa. O valor do parâmetro pode conter variáveis.
Exemplo:
```nginx
location /flv/ {
flv;
limit_rate_after 500k;
limit_rate 50k;
}
```
### lingering_close
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_close` `on` | `always` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------------|
| Padrão | `lingering_close on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Controla como o Angie fecha conexões de cliente.
| `on` | O Angie irá [aguardar](#lingering-timeout) e [processar](#lingering-time) dados adicionais de um cliente antes de fechar completamente uma conexão, mas apenas se a heurística sugerir que um cliente pode estar enviando mais dados. |
|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `always` | O Angie sempre aguardará e processará dados adicionais do cliente. |
| `off` | O Angie não aguardará mais dados e fechará a conexão imediatamente. Este comportamento quebra o protocolo e não deve ser usado em circunstâncias normais. |
Para controlar o fechamento de conexões HTTP/2, a diretiva deve ser especificada no nível [server](#server).
### lingering_time
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_time` time; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | `lingering_time 30s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Quando [lingering_close](#lingering-close) está em vigor, esta diretiva especifica o tempo máximo durante o qual o Angie processará (lerá e ignorará) dados adicionais vindos de um cliente. Após isso, a conexão será fechada, mesmo se houver mais dados.
### lingering_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `lingering_timeout` time; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `lingering_timeout 5s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Quando [lingering_close](#lingering-close) está em vigor, esta diretiva especifica o tempo máximo
de espera para que mais dados do cliente cheguem. Se os dados não forem recebidos durante
este tempo, a conexão é fechada. Caso contrário, os dados são lidos e ignorados,
e o Angie começa a aguardar mais dados novamente. O ciclo "aguardar-ler-ignorar" é
repetido, mas não por mais tempo do que o especificado pela diretiva [lingering_time](#lingering-time).
Durante o desligamento gracioso, conexões keepalive do cliente são fechadas apenas quando
elas estiverem ociosas por pelo menos o tempo especificado em `lingering_timeout`.
#### NOTE
No nginx, a diretiva análoga é chamada [keepalive_min_timeout](https://nginx.org/en/docs/http/ngx_http_core_module.html#keepalive_min_timeout).
### listen
#### Versionchanged
Alterado na versão 1.10.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `listen` address[:port] [`default_server`] [`ssl`] [http2 | `quic`] [`proxy_protocol`] [`setfib=`number] [`fastopen=`number] [`backlog=`number] [`rcvbuf=`size] [`sndbuf=`size] [`accept_filter=`filter] [`deferred`] [`bind`] [`ipv6only=``on` | `off`] [`reuseport`] [`so_keepalive=`on|off|[`keepidle`]:[`keepintvl`]:[`keepcnt`]];
`listen` unix:path [`default_server`] [`ssl`] [http2 | `quic`] [`proxy_protocol`] [`backlog=`number] [`rcvbuf=`size] [`sndbuf=`size] [`accept_filter=`filter] [`deferred`] [`bind`] [`so_keepalive=`on|off|[`keepidle`]:[`keepintvl`]:[`keepcnt`]]; |
|-------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `listen *:80` | `*:8000;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Define o address e a port para o socket de escuta, ou o caminho para um socket de domínio UNIX no qual o servidor aceitará requisições. Um address também pode ser um nome de host, por exemplo:
```nginx
listen 127.0.0.1:8000;
listen 127.0.0.1;
listen 8000;
listen *:8000;
listen localhost:8000;
```
Endereços IPv6 são especificados entre colchetes:
```nginx
listen [::]:8000;
listen [::1];
```
Intervalos de portas são especificados com a primeira e a última porta separadas por hífen:
```nginx
listen 127.0.0.1:8000-8009;
listen 8000-8009;
```
Sockets de domínio UNIX são especificados com o prefixo `unix:`:
```nginx
listen unix:/var/run/angie.sock;
```
Tanto address quanto port, ou apenas address ou apenas port, podem ser especificados.
Quando algumas partes são omitidas, as seguintes regras se aplicam:
- Se apenas o address for fornecido, a porta 80 é usada.
- Se apenas a port for fornecida,
o Angie escuta em todas as interfaces IPv4 (e IPv6, se habilitado) disponíveis.
O primeiro bloco `server` para essa porta
torna-se o servidor padrão para requisições com um cabeçalho `Host` não correspondente.
- Se a diretiva for omitida inteiramente, o Angie usa `*:80`
quando executado com privilégios de superusuário ou `*:8000` caso contrário.
| `default_server` | O servidor com este parâmetro especificado será o servidor padrão para o par address:port fornecido (juntos eles formam um *socket de escuta*).
Se não houver diretivas com o parâmetro `default_server`, o servidor padrão para o socket de escuta será o primeiro servidor na configuração que serve este socket. |
|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `ssl` | indica que todas as conexões aceitas neste socket de escuta devem funcionar em modo SSL. Isso permite uma [configuração mais compacta](https://pt.angie.software//angie/docs/configuration/ssl.md#compact-server) para o servidor que manipula tanto requisições HTTP quanto HTTPS. |
| `http2` | configura a porta para aceitar conexões HTTP/2. Normalmente, para que isso funcione, o parâmetro `ssl` também deve ser especificado, mas o Angie também pode ser configurado para aceitar conexões HTTP/2 sem SSL.
#### Deprecated Descontinuado desde a versão 1.2.0.
Use a diretiva [http2](https://pt.angie.software//angie/docs/configuration/modules/http/http_v2.md#http2) em vez disso. |
| `quic` | configura a porta para aceitar conexões QUIC. Para usar esta opção, o Angie deve ter o [módulo HTTP3](https://pt.angie.software//angie/docs/configuration/modules/http/http_v3.md#http-v3) habilitado e configurado. Com `quic` definido, você também pode especificar `reuseport` para que múltiplos processos worker possam ser usados. |
| `proxy_protocol` | indica que todas as conexões aceitas neste socket de escuta devem usar o protocolo PROXY. |
A diretiva `listen` também pode especificar vários parâmetros adicionais específicos para chamadas de sistema relacionadas a sockets. Estes parâmetros podem ser especificados em qualquer diretiva `listen`, mas apenas uma vez para um determinado socket de escuta:
| `setfib=`number | define a tabela de roteamento, FIB (a opção `SO_SETFIB`) para o socket de escuta. Atualmente isso funciona apenas no FreeBSD. |
|--------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `fastopen=`number | habilita "TCP Fast Open" para o socket de escuta e limita o comprimento máximo para a fila de conexões que ainda não completaram o handshake de três vias.
#### WARNING Não habilite "TCP Fast Open" a menos que o servidor possa lidar com o recebimento do mesmo pacote SYN com dados mais de uma vez. |
| `backlog=`number | define o parâmetro `backlog` na chamada `listen()` que limita o comprimento máximo para a fila de conexões pendentes. Por padrão, backlog é definido como -1 no FreeBSD, DragonFly BSD e macOS, e como 511 em outras plataformas. |
| `rcvbuf=`size | define o tamanho do buffer de recepção (a opção `SO_RCVBUF`) para o socket de escuta. |
| `sndbuf=`size | define o tamanho do buffer de envio (a opção `SO_SNDBUF`) para o socket de escuta. |
| `accept_filter=`filter | define o nome do filtro de aceitação (a opção `SO_ACCEPTFILTER`) para o socket de escuta que filtra conexões de entrada antes de passá-las para `accept()`. Isso funciona apenas no FreeBSD e NetBSD 5.0+. Os valores possíveis são `dataready` e `httpready`. |
| `deferred` | instrui a usar um `accept()` adiado (a opção de socket `TCP_DEFER_ACCEPT`) no Linux. |
| `bind` | instrui a fazer uma chamada `bind()` separada para um determinado par address:port. Isso é útil porque se houver várias diretivas `listen` com a mesma porta mas endereços diferentes, e uma das diretivas `listen` escuta em todos os endereços para a `port` fornecida (`*:port`), o Angie fará `bind()` apenas para `*:port`. Deve-se notar que a chamada de sistema `getsockname()` será feita neste caso para determinar o endereço que aceitou a conexão. Se os parâmetros `setfib`, `fastopen`, `backlog`, `rcvbuf`, `sndbuf`, `accept_filter`, `deferred`, `ipv6only`, `reuseport` ou `so_keepalive` forem usados, então para um determinado par `address:port` uma chamada `bind()` separada sempre será feita. |
| `ipv6only=on` | `off` | determina (via a opção de socket `IPV6_V6ONLY`) se um socket IPv6 escutando em um endereço curinga [::] aceitará apenas conexões IPv6 ou tanto conexões IPv6 quanto IPv4. Este parâmetro está ativado por padrão. Ele só pode ser definido uma vez na inicialização. |
| `reuseport` | instrui a criar um socket de escuta individual para cada processo worker (usando a opção de socket `SO_REUSEPORT` no Linux 3.9+ e DragonFly BSD, ou `SO_REUSEPORT_LB` no FreeBSD 12+), permitindo que um kernel distribua conexões de entrada entre processos worker. Atualmente isso funciona apenas no Linux 3.9+, DragonFly BSD e FreeBSD 12+.
#### WARNING O uso inadequado do parâmetro `reuseport` pode ter implicações de segurança. |
| `multipath` | habilita a aceitação de conexões via [Multipath TCP](https://en.wikipedia.org/wiki/Multipath_TCP) (MPTCP), suportado no kernel Linux desde a versão 5.6. Este parâmetro é **incompatível** com `quic`. |
| `so_keepalive=on` | `off` | [`keepidle`]:[`keepintvl`]:[`keepcnt`] | configura o comportamento de "TCP keepalive" para o socket de escuta.
| `''` | se este parâmetro for omitido, as configurações do sistema operacional estarão em efeito para o socket | |--------|----------------------------------------------------------------------------------------------------------| | `on` | a opção `SO_KEEPALIVE` é ativada para o socket | | `off` | a opção `SO_KEEPALIVE` é desativada para o socket | |
Alguns sistemas operacionais suportam a definição de parâmetros TCP keepalive em uma
base por socket usando as opções de socket `TCP_KEEPIDLE`, `TCP_KEEPINTVL` e
`TCP_KEEPCNT`. Em tais sistemas (atualmente, Linux, NetBSD,
Dragonfly, FreeBSD e macOS), eles podem ser configurados usando os
parâmetros `keepidle`, `keepintvl` e `keepcnt`. Um ou dois
parâmetros podem ser omitidos, caso em que a configuração padrão do sistema para a
opção de socket correspondente estará em efeito. Por exemplo,
```nginx
so_keepalive=30m::10
```
definirá o tempo limite de inatividade (`TCP_KEEPIDLE`) para 30 minutos, deixará o intervalo de sondagem (`TCP_KEEPINTVL`) em seu padrão do sistema, e definirá a contagem de sondagens (`TCP_KEEPCNT`) para 10 sondagens.
Exemplo:
```nginx
listen 127.0.0.1 default_server accept_filter=dataready backlog=1024;
```
### location
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `location` ([ = | ~ | ~\* | ^~ ] uri | `@name`)+ { ... } |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location |
Define a configuração dependendo de se o URI da requisição corresponde
a qualquer uma das expressões de correspondência.
A correspondência é realizada contra um URI normalizado (o valor de
[$uri](#v-uri)), após decodificar o texto
codificado na forma "%XX", resolver referências a componentes de caminho relativo "."
e "..", e possível [compressão](#merge-slashes) de duas ou mais
barras adjacentes em uma única barra.
Um `location` pode ser definido por uma string de prefixo ou por uma expressão
regular.
Expressões regulares são especificadas com o modificador precedente:
| `~*` | Correspondência insensível a maiúsculas e minúsculas |
|--------|--------------------------------------------------------|
| `~` | Correspondência sensível a maiúsculas e minúsculas |
Para encontrar um location que corresponda a uma requisição, o Angie primeiro verifica os
locations definidos com strings de prefixo (locations de prefixo). Entre eles, o location
com o prefixo correspondente mais longo é selecionado e lembrado.
#### NOTE
Para sistemas operacionais insensíveis a maiúsculas e minúsculas como macOS, a correspondência de string de prefixo
é insensível a maiúsculas e minúsculas.
No entanto, a correspondência é limitada a locales de byte único.
Em seguida, as expressões regulares são verificadas na ordem de sua aparição no
arquivo de configuração. A busca para após a primeira correspondência, e a
configuração correspondente é usada. Se nenhuma correspondência com uma expressão regular for encontrada, então a
configuração do location de prefixo lembrado anteriormente é usada.
Com algumas exceções mencionadas abaixo,
blocos `location` podem ser aninhados.
Expressões regulares podem criar grupos de captura
que podem ser usados posteriormente com outras diretivas.
Se o location de prefixo correspondente mais longo tiver o modificador `^~`,
então as expressões regulares não são verificadas.
Além disso, usando o modificador `=`, é possível definir uma correspondência exata de URI e
location. Se uma correspondência exata for encontrada, a busca termina. Por exemplo, se uma
requisição `/` acontece com frequência, definir `location =/` acelerará
o processamento dessas requisições, pois a busca termina após a primeira comparação.
Tal location não pode conter locations aninhados, pois define uma correspondência exata.
Uma vez selecionada a `location` correspondente, a requisição é mapeada para
um arquivo por meio da diretiva [root](#root) ou [alias](#alias), e [try_files](#try-files)
pode verificar arquivos dentro dela; veja [Escolhendo localizações](https://pt.angie.software//angie/docs/configuration/processing.md#pick-location) para uma visão geral.
Exemplo:
```nginx
location =/ {
#configuração A
}
location / {
#configuração B
}
location /documents/ {
#configuração C
}
location ^~/images/ {
#configuração D
}
location ~*\.(gif|jpg|jpeg)$ {
#configuração E
}
```
- Uma requisição `/` corresponderá à configuração A,
- uma requisição `/index.html` corresponderá à configuração B,
- uma requisição `/documents/document.html` corresponderá à configuração C,
- uma requisição `/images/1.gif` corresponderá à configuração D,
- e uma requisição `/documents/1.jpg` corresponderá à configuração E.
#### NOTE
Se um prefixo `location` termina com uma barra e
[auto_redirect](#auto-redirect) está habilitado, ocorre o seguinte:
Quando uma requisição chega com uma URI que não possui barra final
mas que corresponde exatamente ao prefixo, um redirecionamento permanente com código 301
é retornado, apontando para a URI solicitada com a barra anexada.
Com um location de correspondência exata de URI, o redirecionamento não é aplicado:
```nginx
location /user/ {
proxy_pass http://user.example.com;
}
location =/user {
proxy_pass http://login.example.com;
}
```
O prefixo `@` define um `location` *nomeado*. Tais locations não são usados para processamento regular de requisições,
mas são destinados apenas para redirecionamento de requisições.
Eles não podem ser aninhados e não podem conter locations aninhados.
#### Localizações combinadas
Vários contextos `location` que definem blocos de configuração idênticos
podem ser compactados listando todas as suas expressões correspondentes em uma única
`location` com um único bloco de configuração.
Isso é chamado de `location` *combinada*.
Suponha que as configurações A, D e E do exemplo anterior
definam configurações idênticas; você pode combiná-las em uma `location`:
```nginx
location =/
^~/images/
~*\.(gif|jpg|jpeg)$ {
# configuração geral
}
```
Uma `location` nomeada também pode fazer parte da combinação:
```nginx
location =/
@named_combined {
#...
}
```
#### WARNING
Uma `location` combinada não pode ter um espaço entre o modificador
da expressão correspondente e a expressão em si.
Forma correta: `location ~*/match(ing|es|er)$ *...*`.
#### NOTE
Atualmente, uma `location` combinada não pode conter **imediatamente**
diretivas `proxy_pass` com URI definido, nem `api` ou `alias`.
No entanto, essas diretivas podem ser usadas por locations aninhadas
dentro de uma location combinada.
### log_not_found
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `log_not_found` `on` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `log_not_found on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o registro de erros sobre arquivos não encontrados no [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log).
### log_subrequest
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `log_subrequest` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `log_subrequest off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o registro de sub-requisições no [access_log](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#access-log).
### max_headers
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `max_headers` number; |
|-------------------------------------------------------------------------------------------|-------------------------|
| Padrão | `max_headers 1000;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Define o número máximo de campos de cabeçalho de requisição do cliente permitidos.
Se este limite for excedido, um erro `400 (Bad Request)` é retornado.
Quando esta diretiva é definida no nível [server](#server),
o valor do servidor padrão pode ser aplicado.
Para mais informações, consulte a seção [Seleção de servidor virtual](https://pt.angie.software//angie/docs/configuration/processing.md#virtual-server-selection).
### max_ranges
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `max_ranges` number; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita o número máximo permitido de intervalos em requisições byte-range. Requisições que excedem o limite são processadas como se não houvesse intervalos de bytes especificados. Por padrão, o número de intervalos não é limitado.
| `0` | desabilita completamente o suporte a byte-range |
|-------|---------------------------------------------------|
### merge_slashes
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `merge_slashes` `on` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `merge_slashes on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Habilita ou desabilita a compressão de duas ou mais barras adjacentes em um URI em uma única barra.
Note que a compressão é essencial para a correspondência correta de locations de string de prefixo e expressão regular. Sem ela, a requisição `//scripts/one.php` não corresponderia
```nginx
location /scripts/ { }
```
e poderia ser processada como um arquivo estático. Então ela é convertida para `/scripts/one.php`.
Desativar a compressão pode se tornar necessário se um URI contém nomes codificados em base64, já que base64 usa o caractere "/" internamente. No entanto, por considerações de segurança, é melhor evitar desativar a compressão.
Se a diretiva for especificada no nível [server](#server), o valor do servidor padrão pode ser usado.
### msie_padding
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `msie_padding` `on` | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `msie_padding on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a adição de comentários às respostas para clientes MSIE com status maior que 400 para aumentar o tamanho da resposta para 512 bytes.
### msie_refresh
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `msie_refresh` `on` | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão | `msie_refresh off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a emissão de atualizações em vez de redirecionamentos para clientes MSIE.
### open_file_cache
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache` `off`;
`open_file_cache` `max=`N [`inactive=`time]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------|
| Padrão | `open_file_cache off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Configura um cache que pode armazenar:
* descritores de arquivo abertos, seus tamanhos e tempos de modificação;
* informações sobre existência de diretórios;
* erros de busca de arquivo, como "arquivo não encontrado", "sem permissão de leitura", e assim por diante.
O cache de erros deve ser habilitado separadamente pela diretiva [open_file_cache_errors](#open-file-cache-errors).
| `max` | define o número máximo de elementos no cache; no estouro do cache os elementos menos recentemente usados (LRU) são removidos |
|------------|--------------------------------------------------------------------------------------------------------------------------------------|
| `inactive` | define um tempo após o qual um elemento é removido do cache se não foi acessado durante este tempo;
por padrão, 60 segundos |
| `off` | desabilita o cache |
Exemplo:
```nginx
open_file_cache max=1000 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 2;
open_file_cache_errors on;
```
### open_file_cache_errors
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_errors` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão | `open_file_cache_errors off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o cache de erros de busca de arquivo por [open_file_cache](#open-file-cache).
### open_file_cache_events
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_events` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão | `open_file_cache_events off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita o uso de eventos de kernel para validar elementos do [open_file_cache](#open-file-cache).
Esta diretiva funciona somente com o método [kqueue](https://pt.angie.software//angie/docs/configuration/processing.md#kqueue). Observe que apenas
o NetBSD 2.0+ e o FreeBSD 6.0+ suportam eventos para tipos de sistema de arquivos
arbitrários; outros sistemas operacionais suportam eventos somente para sistemas de
arquivos essenciais como UFS ou FFS.
### open_file_cache_min_uses
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_min_uses` number; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | `open_file_cache_min_uses 1;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o número mínimo de acessos ao arquivo durante o período configurado pelo parâmetro `inactive` da diretiva [open_file_cache](#open-file-cache), necessário para que um descritor de arquivo permaneça aberto no cache.
### open_file_cache_valid
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `open_file_cache_valid` time; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `open_file_cache_valid 60s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um tempo após o qual os elementos do [open_file_cache](#open-file-cache) devem ser validados.
### output_buffers
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `output_buffers` number size; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `output_buffers 2 32k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o número e o tamanho dos buffers usados para ler uma resposta do disco.
### port_in_redirect
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `port_in_redirect` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão | `port_in_redirect on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a especificação da porta em redirecionamentos [absolutos](#absolute-redirect) emitidos pelo Angie.
O uso do nome do servidor primário em redirecionamentos é controlado pela diretiva [server_name_in_redirect](#server-name-in-redirect).
### postpone_output
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `postpone_output` size; |
|-------------------------------------------------------------------------------------------|---------------------------|
| Padrão | `postpone_output 1460;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Se possível, a transmissão de dados do cliente será adiada até que o Angie tenha pelo menos o número especificado de bytes para enviar.
| `0` | desabilita o adiamento da transmissão de dados |
|-------|--------------------------------------------------|
### read_ahead
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `read_ahead` size; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | `read_ahead 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define a quantidade de pré-leitura para o kernel ao trabalhar com arquivos.
No Linux, a chamada de sistema `posix_fadvise(0, 0, 0, POSIX_FADV_SEQUENTIAL)` é usada, e portanto o parâmetro size é ignorado.
No FreeBSD, a chamada de sistema `fcntl(O_READAHEAD,` size ), suportada desde FreeBSD 9.0-CURRENT, é usada.
### recursive_error_pages
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `recursive_error_pages` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão | `recursive_error_pages off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita fazer vários redirecionamentos usando a diretiva [error_page](#error-page). O número de tais redirecionamentos é [limitado](#internal).
### request_pool_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `request_pool_size` size; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `request_pool_size 4k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Permite o ajuste preciso das alocações de memória por requisição. Esta diretiva tem impacto mínimo no desempenho e geralmente não deve ser usada.
### reset_timedout_connection
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `reset_timedout_connection` `on` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão | `reset_timedout_connection off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o reset de conexões que expiraram e conexões fechadas com o código não-padrão 444. O reset é realizado da seguinte forma. Antes de fechar um socket, a opção `SO_LINGER` é definida para ele com um valor de timeout de 0. Quando o socket é fechado, TCP RST é enviado para o cliente, e toda a memória associada a este socket é liberada. Isso ajuda a evitar manter um socket já fechado no estado FIN_WAIT1 com buffers preenchidos por muito tempo.
#### NOTE
conexões keep-alive são fechadas normalmente quando expiram.
### resolver
#### Versionchanged
Alterado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `resolver` [address ...] [`conf` [`=`file]] [`valid=`time] [`ipv4=``on` | `off`] [`ipv6=``on` | `off`] [`status_zone=`zone];
`resolver` `off`; |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | `resolver conf;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, upstream |
Configura servidores de nomes usados para resolver nomes de servidores upstream em endereços, por exemplo:
```nginx
resolver 127.0.0.53 [::1]:5353;
```
O endereço pode ser especificado como um nome de domínio ou endereço IP, com uma porta opcional. Se a porta não for especificada, a porta 53 é usada. Os servidores de nomes são consultados em modo round-robin.
Deve ser especificado pelo menos um endereço de servidor DNS ou o parâmetro
`conf`, exceto na forma `resolver off;`.
#### NOTE
Recomenda-se usar um resolver local confiável, como `127.0.0.53`
(systemd-resolved), em vez de um público (p.ex., `8.8.8.8`). Resolvers
públicos expõem consultas DNS a terceiros e aumentam o risco de ataques de
envenenamento de cache.
#### NOTE
O valor da diretiva é herdado por blocos aninhados
e pode ser sobrescrito neles se necessário.
Dentro de um único bloco, a diretiva só pode ser especificada uma vez;
repeti-la é um erro de configuração.
Esta diretiva habilita a resolução de nomes DNS. É usada para servidores upstream referenciados por meio de variáveis ou configurados com o parâmetro [resolve](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve), bem como pelo cliente ACME e pelo grampeamento OCSP.
Além de endereços de servidor explícitos, a diretiva reconhece:
| `off` | desabilita explicitamente a resolução de nomes DNS |
|------------------|-----------------------------------------------------------------------------------------------------------------------|
| `conf` [`=`file] | lê endereços de servidor DNS do arquivo especificado, ou de `/etc/resolv.conf` se nenhum arquivo for especificado |
O arquivo pode conter linhas `nameserver` no mesmo formato usado pelo resolver do sistema:
```text
nameserver 127.0.1.4
nameserver 127.0.1.5
```
Os endereços lidos do arquivo são adicionados a quaisquer endereços especificados explicitamente na diretiva, e todos eles são então consultados juntos em modo round-robin. Se o arquivo estiver ausente, não puder ser lido ou não listar nenhum endereço, e nenhum estiver configurado explicitamente, o Angie recorre ao servidor padrão `127.0.0.1:53`.
O Angie relê o arquivo automaticamente quando ele muda, atualizando o conjunto ativo de servidores de acordo.
Por padrão, o Angie faz cache de cada resposta durante o período de validade do valor TTL na resposta DNS. O parâmetro opcional `valid` permite sobrescrever isso:
| `valid` | parâmetro *opcional* que permite sobrescrever o período de validade do cache de resposta |
|-----------|--------------------------------------------------------------------------------------------|
```nginx
resolver 127.0.0.53 [::1]:5353 valid=30s;
```
Por padrão, o Angie procurará tanto endereços IPv4 quanto IPv6 durante a resolução.
| `ipv4=off` | desabilita a busca de endereços IPv4 |
|--------------|----------------------------------------|
| `ipv6=off` | desabilita a busca de endereços IPv6 |
| `status_zone` | parâmetro *opcional*; habilita a coleta de métricas de solicitação e resposta do servidor DNS na zona especificada, expondo-as em [/status/resolvers/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-resolvers), na [aba «DNS Resolvers»](https://pt.angie.software//angie/docs/configuration/monitoring.md#samp-dns-resolvers-tab), e na saída do [Prometheus](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus). Sem ele, essas métricas não são coletadas e nenhum aviso é registrado |
|-----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
### resolver_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `resolver_timeout` time; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `resolver_timeout 30s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, upstream |
Define um timeout para resolução de nomes, por exemplo:
```nginx
resolver_timeout 5s;
```
### root
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `root` path; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `root html;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define o diretório raiz para solicitações. Por exemplo, com a seguinte configuração
```nginx
location /i/ {
root /data/w3;
}
```
O arquivo `/data/w3/i/top.gif` será enviado em resposta à solicitação `/i/top.gif`.
O valor path pode conter variáveis, exceto [$document_root](#v-document-root) e [$realpath_root](#v-realpath-root).
Um caminho para o arquivo é construído simplesmente adicionando uma URI ao valor da diretiva root. Se uma URI precisa ser modificada, a diretiva [alias](#alias) deve ser usada. Uma barra final no valor de path é descartada, pois o URI é acrescentado com sua própria barra inicial.
### satisfy
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `satisfy` `all` | `any`; |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão | `satisfy all;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite acesso se todos (`all`) ou pelo menos um (`any`) dos módulos [Access](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access), [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic), ou [Auth Request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request) permitirem acesso.
```nginx
location / {
satisfy any;
allow 192.168.1.0/32;
deny all;
auth_basic "closed site";
auth_basic_user_file conf/htpasswd;
}
```
### send_lowat
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `send_lowat` size; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | `send_lowat 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Se a diretiva for definida com um valor diferente de zero, o Angie tentará minimizar o número de operações de envio nos sockets do cliente usando a flag `NOTE_LOWAT` do método [kqueue](https://pt.angie.software//angie/docs/configuration/processing.md#kqueue) ou a opção de socket `SO_SNDLOWAT`. Em ambos os casos, o tamanho especificado é usado.
### send_timeout
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `send_timeout` time; |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão | `send_timeout 60s;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um timeout para transmitir uma resposta ao cliente. O timeout é definido apenas entre duas operações de escrita sucessivas, não para a transmissão de toda a resposta. Se o cliente não receber nada dentro deste tempo, a conexão é fechada.
### sendfile
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `sendfile` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `sendfile off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Habilita ou desabilita o uso de `sendfile()`.
[aio](#aio) pode ser usado para pré-carregar dados para `sendfile()`:
```nginx
location /video/ {
sendfile on;
tcp_nopush on;
aio on;
}
```
Nesta configuração, `sendfile()` é chamado com a flag `SF_NODISKIO` que faz com que não bloqueie na E/S do disco, mas, em vez disso, reporte que os dados não estão na memória. O Angie então inicia um carregamento assíncrono de dados lendo um byte. Na primeira leitura, o kernel do FreeBSD carrega os primeiros 128K bytes de um arquivo na memória, embora as próximas leituras carreguem apenas dados em blocos de 16K. Isso pode ser alterado usando a diretiva [read_ahead](#read-ahead).
### sendfile_max_chunk
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `sendfile_max_chunk` size; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | `sendfile_max_chunk 2m;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Limita a quantidade de dados que pode ser transferida em uma única chamada `sendfile()`. Sem o limite, uma conexão rápida pode monopolizar completamente o processo worker.
### server
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server` { ... } |
|-------------------------------------------------------------------------------------------|--------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define a configuração para um servidor virtual. Não há separação clara entre servidores virtuais baseados em IP (baseados no endereço IP) e baseados em nome (baseados no campo de cabeçalho de solicitação "Host"). Em vez disso, as diretivas [listen](#listen) descrevem todos os endereços e portas que devem aceitar conexões para o servidor, e a diretiva [server_name](#server-name) lista todos os nomes de servidor.
Exemplos de configurações são fornecidos no documento [Como o Angie processa uma solicitação](https://pt.angie.software//angie/docs/configuration/processing.md#request-processing).
### server_name
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_name` name ...; |
|-------------------------------------------------------------------------------------------|---------------------------|
| Padrão | `server_name ""`; |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Define nomes de um servidor virtual, por exemplo:
```nginx
server {
server_name example.com www.example.com;
}
```
O primeiro nome torna-se o nome primário do servidor.
Nomes de servidor podem incluir um asterisco ("\*") substituindo a primeira ou última parte de um nome:
```nginx
server {
server_name example.com *.example.com www.example.*;
}
```
Tais nomes são chamados de nomes curinga.
Os dois primeiros nomes mencionados acima podem ser combinados em um:
```nginx
server {
server_name .example.com;
}
```
Também é possível usar expressões regulares em nomes de servidor, precedendo o nome com um til ("~"):
```nginx
server {
server_name ~^www\d+\.example\.com$ www.example.com;
}
```
Expressões regulares podem conter capturas que podem ser usadas posteriormente em outras diretivas:
```nginx
server {
server_name ~^(www\.)?(.+)$;
location / {
root /sites/$2;
}
}
server {
server_name _;
location / {
root /sites/default;
}
}
```
Capturas nomeadas em expressões regulares criam variáveis
que podem ser usadas posteriormente em outras diretivas:
```nginx
server {
server_name ~^(www\.)?(?.+)$;
location / {
root /sites/$domain;
}
}
server {
server_name _;
location / {
root /sites/default;
}
}
```
#### NOTE
Se o parâmetro da diretiva for definido como [$hostname](#v-hostname),
o nome da máquina é usado.
Um nome de servidor vazio também pode ser especificado:
```nginx
server {
server_name www.example.com "";
}
```
Ao procurar um servidor virtual por nome,
se o nome corresponder a mais de uma das variantes especificadas
(por exemplo, tanto um nome curinga quanto uma expressão regular correspondem),
a primeira variante correspondente será escolhida, na seguinte ordem de prioridade:
- nome exato;
- nome curinga mais longo começando com um asterisco, por exemplo `*.example.com`;
- nome curinga mais longo terminando com um asterisco, por exemplo `mail.*`;
- primeira expressão regular correspondente (na ordem de aparição no arquivo de configuração),
incluindo um nome vazio.
#### WARNING
Para usar `server_name` com TLS,
a terminação da conexão TLS é necessária.
Esta diretiva corresponde ao `Host` na solicitação HTTP,
então o handshake deve ser completado e a conexão descriptografada.
### server_name_in_redirect
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_name_in_redirect` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-------------------------------------------|
| Padrão | `server_name_in_redirect off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o uso do nome do servidor primário, especificado pela diretiva [server_name](#server-name), em [redirecionamentos absolutos](#absolute-redirect) emitidos pelo Angie.
| `on` | o nome do servidor primário definido pela diretiva [server_name](#server-name) é usado |
|--------|-----------------------------------------------------------------------------------------------------------------------------------|
| `off` | o nome do campo de cabeçalho de requisição "Host" é usado. Se este campo não estiver presente, o endereço IP do servidor é usado. |
O uso da porta em redirecionamentos é controlado pela diretiva [port_in_redirect](#port-in-redirect).
### server_names_hash_bucket_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_names_hash_bucket_size` size; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------|
| Padrão | `server_names_hash_bucket_size 32` | `64` | `128;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define o tamanho do bucket para as tabelas hash de nomes de servidor. O valor padrão depende do tamanho da linha de cache do processador. Os detalhes da configuração de tabelas hash são fornecidos em um [documento separado](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### server_names_hash_max_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_names_hash_max_size` size; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | `server_names_hash_max_size 512`; |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define o tamanho máximo das tabelas hash de nomes de servidor. Os detalhes da configuração de tabelas hash são fornecidos em um [documento separado](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### server_tokens
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `server_tokens` `on` | `off` | `build` | string; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------|
| Padrão | `server_tokens on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a emissão da versão do Angie
em páginas de erro e no campo de cabeçalho de resposta `Server`.
O parâmetro `build` habilita a emissão do nome da build,
definido pelo respectivo parâmetro [configure](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure),
junto com a versão.
No Angie PRO, se a diretiva define uma string, que também pode conter variáveis,
as páginas de erro e o campo de cabeçalho de resposta `Server`
usarão o valor interpolado das variáveis da string
em vez do nome do servidor, versão e nome da build.
Uma string vazia desabilita a emissão do campo `Server`.
### status_zone
#### Versionchanged
Alterado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `status_zone` `off` | zone | key `zone=`zone[:number]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location, if in location |
Aloca uma zona de memória compartilhada para coletar
métricas de [/status/http/location_zones/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-location-zones) e [/status/http/server_zones/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-server-zones).
Vários contextos `server`
podem compartilhar a mesma zona para coleta de dados;
o valor especial `off`
desabilita a coleta de dados em blocos `location` aninhados.
A sintaxe com um único valor zone
combina todas as métricas para o contexto atual em uma zona de memória compartilhada:
```nginx
server {
listen 80;
server_name *.example.com;
status_zone single;
# ...
}
```
A sintaxe alternativa permite definir os seguintes parâmetros:
| key | Uma string com variáveis, cujo valor determina o agrupamento de requisições na zona. Todas as requisições que produzem valores idênticos após substituição são agrupadas juntas. Se a substituição produzir um valor vazio, as métricas não são atualizadas. |
|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| zone | O nome da zona de memória compartilhada. |
| number (opcional) | O número máximo de grupos separados para coletar métricas. Se novos valores de key excederem este limite, eles são agrupados sob `zone`.
O valor padrão é 1. |
No exemplo a seguir,
todas as requisições que compartilham o mesmo valor `$host`
são agrupadas na `host_zone`.
As métricas são rastreadas separadamente para cada `$host` único
até que haja 10 grupos de métricas.
Uma vez que este limite seja atingido,
quaisquer valores `$host` adicionais são incluídos sob a `host_zone`:
```nginx
server {
listen 80;
server_name *.example.com;
status_zone $host zone=host_zone:10;
location / {
proxy_pass http://example.com;
}
}
```
As métricas resultantes são assim divididas entre hosts individuais na saída da API.
#### NOTE
Essas métricas são coletadas apenas quando `status_zone` está definido. Sem ele,
o servidor ou location não aparece em [/status/http/server_zones/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-server-zones),
[/status/http/location_zones/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-http-location-zones), no [widget «HTTP Zones»](https://pt.angie.software//angie/docs/configuration/monitoring.md#http-zones-widget), na saída do
[Prometheus](https://pt.angie.software//angie/docs/configuration/modules/http/http_prometheus.md#http-prometheus), e nenhum aviso é registrado.
Consulte [exemplo de configuração](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#example-configuration).
### subrequest_output_buffer_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `subrequest_output_buffer_size` size; |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão | `subrequest_output_buffer_size 4k` | `8k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tamanho do buffer usado para armazenar o corpo da resposta de uma subrequisição.
Por padrão, o tamanho do buffer é igual a uma página de memória. Isso é
`4K` ou `8K`, dependendo da plataforma. Pode ser feito menor,
no entanto.
#### NOTE
A diretiva é aplicável apenas para subrequisições com corpos de resposta salvos na memória. Por exemplo, tais subrequisições são criadas por [SSI](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssi.md#ssi-include-set).
### tcp_nodelay
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `tcp_nodelay` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão | `tcp_nodelay on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o uso da opção `TCP_NODELAY`. A opção é habilitada quando uma conexão é transicionada para o estado keep-alive. Adicionalmente, é habilitada em conexões SSL, para proxy sem buffer, e para [proxy WebSocket](https://pt.angie.software//angie/docs/configuration/processing.md#websocket-proxy).
### tcp_nopush
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `tcp_nopush` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | `tcp_nopush off`; |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita o uso da opção de socket `TCP_NOPUSH` no FreeBSD ou da opção de socket `TCP_CORK` no Linux. As opções são habilitadas apenas quando [sendfile](#sendfile) é usado. Habilitar a opção permite
* enviar o cabeçalho da resposta e o início de um arquivo em um pacote, no Linux e FreeBSD 4.\*;
* enviar um arquivo em pacotes completos.
### time_format
#### Versionadded
Adicionado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `time_format` $variable format; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define uma $variable para conter a hora local atual, renderizada com uma
string format personalizada composta por especificadores no estilo
`strftime` mais `%L` para milissegundos. A diretiva é útil quando
[$time_local](#v-time-local) e [$time_iso8601](#v-time-iso8601)
não são suficientes, por exemplo porque não fornecem precisão de subsegundo:
```nginx
time_format $time_ms "%Y-%m-%dT%H:%M:%S.%L%Z";
log_format tf '$time_ms $remote_addr "$request" $status';
```
Com o formato acima, `$time_ms` se expande para um valor como
`2024-01-15T14:34:56.789+03:00`.
Redefinir uma variável integrada, como [$time_local](#v-time-local), ou
repetir `time_format` para o mesmo nome faz a carga da configuração
falhar com um erro como: "the duplicate "..." variable".
A string format aceita os seguintes especificadores, avaliados no mesmo
fuso horário local que [$time_local](#v-time-local):
| `%Y` | ano com 4 dígitos |
|------------|---------------------------------------------------------|
| `%y` | ano com 2 dígitos |
| `%m` | mês, `01-12` |
| `%d` | dia do mês, `01-31` |
| `%e` | dia do mês, preenchido com espaços, `1-31` |
| `%H` | hora, `00-23` |
| `%I` | hora, `01-12` |
| `%M` | minuto, `00-59` |
| `%S` | segundo, `00-59` |
| `%L` | milissegundos, `000-999` |
| `%p` | `AM` / `PM` em maiúsculas |
| `%P` | `am` / `pm` em minúsculas |
| `%a` | nome abreviado do dia da semana, `Sun-Sat` |
| `%A` | nome completo do dia da semana, `Sunday-Saturday` |
| `%b`, `%h` | nome abreviado do mês, `Jan-Dec` |
| `%B` | nome completo do mês, `January-December` |
| `%z` | deslocamento de fuso horário, `+0300` |
| `%Z` | deslocamento de fuso horário, estilo ISO 8601, `+03:00` |
| `%n` | quebra de linha |
| `%t` | tabulação |
| `%%` | `%` literal |
#### NOTE
Um especificador não reconhecido é copiado literalmente para a saída,
incluindo o `%` inicial; um `%` isolado no final da string
format é descartado.
### try_files
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `try_files` file ... uri;
`try_files` file ... =code; |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server, location |
Verifica a existência de arquivos na ordem especificada e usa o primeiro arquivo encontrado para o processamento da requisição; o processamento é realizado no contexto da [location](#location) atual. O caminho para um arquivo é construído a partir do parâmetro file de acordo com as diretivas [root](#root) e [alias](#alias). É possível verificar a existência de um diretório especificando uma barra no final do nome, por exemplo `$uri/`. Se nenhum dos arquivos for encontrado, um redirecionamento interno para o uri especificado no último parâmetro é feito.
Os parâmetros file e uri podem conter variáveis.
Por exemplo:
```nginx
location /images/ {
try_files $uri /images/default.gif;
}
location = /images/default.gif {
expires 30s;
}
```
O último parâmetro pode ser um URI para um redirecionamento interno,
uma referência a uma `location` nomeada (por exemplo, `@drupal`),
ou um código de resposta na forma `=code` (por exemplo, `=404`):
```nginx
location / {
try_files $uri $uri/index.html $uri.html =404;
}
```
Deve-se notar que o uso excessivo da diretiva `try_files`
aumenta o número de chamadas de sistema,
o que pode impactar negativamente o desempenho.
Assim, `try_files` não deve ser usado para replicar comportamento
que é efetivamente o comportamento padrão, por exemplo:
```nginx
location /bad_pattern {
# try_files $uri $uri/ =404; # não recomendado!
}
```
Além disso, `try_files` não deve ser usado
apenas para redirecionar quando um arquivo está ausente.
A razão é que a diretiva `try_files` tem duas peculiaridades:
- Primeiro, ela verifica a existência de cada arquivo,
o que aumenta a carga do sistema.
- Segundo, quaisquer erros de abertura de arquivo (por exemplo, `too many open files`,
erros de permissão) também são tratados como ausência de arquivo e acionam um fallback
para o manipulador de backup, o que pode mascarar erros 5xx com respostas bem-sucedidas
e levar a cache incorreto.
Assim, na prática, a seguinte construção problemática pode ser encontrada:
```nginx
location / {
try_files $uri $uri/ @drupal; # não recomendado!
}
```
O problema aqui é que o único propósito é o redirecionamento.
Usar `try_files` leva às desvantagens listadas acima,
mas não fornece benefícios,
já que verificar a existência do arquivo não é necessário.
A solução correta é usar a diretiva [error_page](#error-page),
que não tem essas desvantagens:
```nginx
error_page 404 = @drupal;
log_not_found off;
```
Em contraste, no exemplo a seguir:
```nginx
location ~ \.php$ {
try_files $uri @drupal;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
# ...
}
```
A diretiva `try_files` verifica a existência do arquivo PHP
antes de passar a requisição para o servidor FastCGI configurado no mesmo bloco;
aqui o uso de `try_files` é justificado.
### Exemplo de uso ao fazer proxy para Mongrel:
```nginx
location / {
try_files /system/maintenance.html
$uri $uri/index.html $uri.html
@mongrel;
}
location @mongrel {
proxy_pass http://mongrel;
}
```
### Exemplo de uso com Drupal/FastCGI:
```nginx
location / {
error_page 404 = @drupal;
}
location ~ \.php$ {
try_files $uri @drupal;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
fastcgi_param SCRIPT_NAME $fastcgi_script_name;
fastcgi_param QUERY_STRING $args;
# ... outros fastcgi_param
}
location @drupal {
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to/index.php;
fastcgi_param SCRIPT_NAME /index.php;
fastcgi_param QUERY_STRING q=$uri&$args;
# ... outros fastcgi_param
}
```
### Exemplo de uso com Wordpress e Joomla:
```nginx
location / {
error_page 404 = @wordpress;
}
location ~ \.php$ {
try_files $uri @wordpress;
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to$fastcgi_script_name;
# ... outros fastcgi_param
}
location @wordpress {
fastcgi_pass ...;
fastcgi_param SCRIPT_FILENAME /path/to/index.php;
# ... outros fastcgi_param
}
```
### types
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `types` { ... } |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------|
| Padrão | `types *text/html html; image/gif gif; image/jpeg jpg;* ` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Mapeia extensões de nomes de arquivo para tipos MIME de respostas. As extensões não diferenciam maiúsculas de minúsculas. Várias extensões podem ser mapeadas para um tipo, por exemplo:
```nginx
types {
application/octet-stream bin exe dll;
application/octet-stream deb;
application/octet-stream dmg;
}
```
Uma tabela de mapeamento suficientemente completa é distribuída com o Angie e está localizada no arquivo `conf/mime.types`.
Para fazer um `location` específico retornar o tipo MIME "application/octet-stream" para todas as respostas, a seguinte configuração pode ser usada:
```nginx
location /download/ {
types { }
default_type application/octet-stream;
}
```
### types_hash_bucket_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `types_hash_bucket_size` size; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `types_hash_bucket_size 64;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tamanho do bucket para as tabelas hash de tipos. Os detalhes da configuração de tabelas hash são discutidos [separadamente](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### types_hash_max_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `types_hash_max_size` size; |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão | `types_hash_max_size 1024;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o tamanho máximo das tabelas hash de tipos. Os detalhes da configuração de tabelas hash são discutidos [separadamente](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### underscores_in_headers
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `underscores_in_headers` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão | `underscores_in_headers off`; |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server |
Habilita ou desabilita o uso de sublinhados em campos de cabeçalho de requisição do cliente. Quando o uso de sublinhados está desabilitado, campos de cabeçalho de requisição cujos nomes contêm sublinhados são marcados como inválidos e estão sujeitos à diretiva [ignore_invalid_headers](#ignore-invalid-headers).
Se a diretiva for especificada no nível [server](#server), o valor do servidor padrão pode ser usado.
### variables_hash_bucket_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `variables_hash_bucket_size` size; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | `variables_hash_bucket_size 64;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define o tamanho do bucket para a tabela hash de variáveis. Os detalhes da configuração de tabelas hash são discutidos [separadamente](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
### variables_hash_max_size
#### Versionchanged
Alterado na versão 1.11.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `variables_hash_max_size` size; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | `variables_hash_max_size 2048;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define o tamanho máximo da tabela hash de variáveis. Os detalhes da configuração de tabelas hash são discutidos [separadamente](https://pt.angie.software//angie/docs/configuration/configfile.md#configure-hashes).
## Variáveis Integradas
O módulo `http_core` suporta variáveis integradas com nomes correspondentes às
variáveis do Apache Server. Em primeiro lugar, estas são variáveis que representam campos
de cabeçalho de requisição do cliente, como `$http_user_agent`, `$http_cookie`,
e assim por diante. Além disso, existem outras variáveis:
### `$angie_version`
versão do Angie
### `$arg_`
argumento name na linha de requisição
### `$args`
argumentos na linha de requisição
### `$binary_remote_addr`
endereço do cliente em forma binária, o comprimento do valor é sempre 4 bytes para endereços IPv4 ou 16 bytes para endereços IPv6
### `$body_bytes_sent`
número de bytes enviados ao cliente, não contando o cabeçalho de resposta; esta variável é compatível com o parâmetro "%B" do módulo `mod_log_config` do Apache
### `$bytes_sent`
número de bytes enviados a um cliente
### `$connection`
número serial da conexão
### `$connection_requests`
número atual de requisições feitas através de uma conexão
### `$connection_time`
tempo de conexão em segundos com resolução de milissegundos
### `$content_length`
campo de cabeçalho de requisição `Content-Length`
### `$content_type`
campo de cabeçalho de requisição `Content-Type`
### `$cookie_`
cookie com o name especificado
### `$document_root`
valor da diretiva [root](#root) ou [alias](#alias) para a requisição atual
### `$document_uri`
mesmo que [$uri](#v-uri)
### `$host`
nesta ordem de precedência: nome do host da linha de requisição, ou nome do host do campo de cabeçalho de requisição "Host", ou o nome do servidor correspondente a uma requisição
### `$hostname`
nome do host
### `$http_`
#### Versionchanged
Alterado na versão 1.11.0: Em requisições HTTP/3, `$http_host` é inicializado a partir do
pseudo-cabeçalho `:authority` se o cabeçalho `Host` não
foi passado pelo cliente.
campo de cabeçalho de requisição arbitrário; a última parte do nome da variável corresponde ao nome do campo convertido para minúsculas com traços substituídos por sublinhados
### `$https`
`on` se a conexão opera em modo SSL, ou uma string vazia caso contrário
### `$is_args`
`?` se uma linha de requisição tem argumentos, ou uma string vazia caso contrário
### `$is_request_port`
`:` se o valor de [$request_port](#v-request-port) não está vazio, ou uma string vazia caso contrário
### `$limit_rate`
definir esta variável habilita limitação de taxa de resposta; veja [limit_rate](#limit-rate)
### `$msec`
tempo atual em segundos com resolução de milissegundos
### `$nginx_version`
versão do nginx
### `$pid`
PID do processo worker
### `$pipe`
`p` se a requisição foi pipelined, `.` caso contrário
### `$proxy_protocol_addr`
endereço do cliente do cabeçalho do protocolo PROXY
O protocolo PROXY deve ser previamente habilitado definindo o parâmetro `proxy_protocol` na diretiva [listen](#listen).
### `$proxy_protocol_port`
porta do cliente do cabeçalho do protocolo PROXY
O protocolo PROXY deve ser previamente habilitado definindo o parâmetro `proxy_protocol` na diretiva [listen](#listen).
### `$proxy_protocol_server_addr`
endereço do servidor do cabeçalho do protocolo PROXY
O protocolo PROXY deve ser previamente habilitado definindo o parâmetro `proxy_protocol` na diretiva [listen](#listen).
### `$proxy_protocol_server_port`
porta do servidor do cabeçalho do protocolo PROXY
O protocolo PROXY deve ser previamente habilitado definindo o parâmetro `proxy_protocol` na diretiva [listen](#listen).
### `$proxy_protocol_tlv_`
TLV do cabeçalho do protocolo PROXY. O name pode ser um nome de tipo TLV ou seu valor numérico. No último caso, o valor é hexadecimal e deve ser prefixado com `0x`:
```none
$proxy_protocol_tlv_alpn
$proxy_protocol_tlv_0x01
```
TLVs SSL também podem ser acessados por nome de tipo TLV ou seu valor numérico, ambos prefixados por `ssl_`:
```none
$proxy_protocol_tlv_ssl_version
$proxy_protocol_tlv_ssl_0x21
```
Os seguintes nomes de tipo TLV são suportados:
* `alpn (0x01)` - protocolo de camada superior usado sobre a conexão
* `authority (0x02)` - valor do nome do host passado pelo cliente
* `unique_id (0x05)` - id único da conexão
* `netns (0x30)` - nome do namespace
* `ssl (0x20)` - estrutura TLV SSL binária
Os seguintes nomes de tipo SSL TLV são suportados:
* `ssl_version (0x21)` - versão SSL usada na conexão do cliente
* `ssl_cn (0x22)` - Nome Comum do certificado SSL
* `ssl_cipher (0x23)` - nome da cifra usada
* `ssl_sig_alg (0x24)` - algoritmo usado para assinar o certificado
* `ssl_key_alg (0x25)` - algoritmo de chave pública
Além disso, o seguinte nome de tipo SSL TLV especial é suportado:
* `ssl_verify` - resultado da verificação do certificado SSL do cliente: `0` se o cliente apresentou um certificado e foi verificado com sucesso, diferente de zero caso contrário
O protocolo PROXY deve ser previamente habilitado definindo o parâmetro `proxy_protocol` na diretiva [listen](#listen).
### `$query_string`
mesmo que [$args](#v-args)
### `$realpath_root`
um nome de caminho absoluto correspondente ao valor da diretiva [root](#root) ou [alias](#alias) para a requisição atual, com todos os links simbólicos resolvidos para caminhos reais
### `$remote_addr`
endereço do cliente
### `$remote_port`
porta do cliente
### `$remote_user`
nome de usuário fornecido com a autenticação Basic
### `$request`
linha de requisição original completa
### `$request_body`
corpo da requisição
O valor da variável é *disponibilizado* em localizações processadas pelas diretivas [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass), [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [uwsgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass), e [scgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass) quando o corpo da requisição foi lido para um [buffer de memória](#client-body-buffer-size).
### `$request_body_file`
nome de um arquivo temporário com o corpo da requisição
No final do processamento, o arquivo precisa ser removido. Para sempre escrever o corpo da requisição em um arquivo, habilite [client_body_in_file_only](#client-body-in-file-only). Ao passar o nome de um arquivo temporário em uma requisição proxy ou em uma requisição para um servidor FastCGI/uwsgi/SCGI, a passagem do próprio corpo da requisição deve ser desabilitada com as diretivas [proxy_pass_request_body off](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass-request-body), [fastcgi_pass_request_body off](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass-request-body), [uwsgi_pass_request_body off](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-pass-request-body), ou [scgi_pass_request_body off](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-pass-request-body), respectivamente.
### `$request_completion`
`OK` se uma requisição foi completada, ou uma string vazia caso contrário
### `$request_filename`
caminho do arquivo para a requisição atual, baseado nas diretivas [root](#root) ou [alias](#alias), e na URI da requisição
### `$request_id`
identificador único da requisição gerado a partir de 16 bytes aleatórios, em hexadecimal
### `$request_length`
comprimento da requisição (incluindo linha de requisição, cabeçalho e corpo da requisição)
### `$request_method`
método da requisição, geralmente `GET` ou `POST`
### `$request_port`
nesta ordem de precedência: número da porta do componente de autoridade da URI da requisição, ou número da porta do campo de cabeçalho de requisição "Host"
### `$request_time`
tempo de processamento da requisição em segundos com resolução de milissegundos; tempo decorrido desde que os primeiros bytes foram lidos do cliente
### `$request_uri`
URI completa original da requisição (com argumentos), nunca modificada durante o processamento da requisição; veja [$uri](#v-uri) para o URI atual (potencialmente reescrito)
### `$scheme`
esquema da requisição, "http" ou "https"
### `$sent_body`
#### Versionadded
Adicionado na versão 1.11.0.
corpo de resposta de uma subrequisição ou requisição externa quando armazenado em memória;
caso contrário, uma string vazia
### `$sent_http_`
campo de cabeçalho de resposta arbitrário; a última parte do nome da variável corresponde ao nome do campo convertido para minúsculas com traços substituídos por sublinhados
### `$sent_trailer_`
campo arbitrário enviado no final da resposta; a última parte do nome da variável corresponde ao nome do campo convertido para minúsculas com traços substituídos por sublinhados
### `$server_addr`
endereço do servidor que aceitou uma requisição
Calcular o valor desta variável geralmente requer uma chamada de sistema. Para evitar uma chamada de sistema, as diretivas [listen](#listen) devem especificar endereços e usar o parâmetro `bind`.
### `$server_name`
nome do servidor que aceitou uma requisição
### `$server_port`
porta do servidor que aceitou uma requisição
### `$server_protocol`
protocolo da requisição, geralmente "HTTP/1.0", "HTTP/1.1", ou "HTTP/2.0"
### `$status`
status da resposta
### `$tcpinfo_rtt, $tcpinfo_rttvar, $tcpinfo_snd_cwnd, $tcpinfo_rcv_space`
informações sobre a conexão TCP do cliente; disponível em sistemas que suportam a opção de socket `TCP_INFO`
### `$time_iso8601`
hora local no formato padrão ISO 8601
### `$time_local`
hora local no formato Common Log Format
### `$uri`
URI atual na requisição, [normalizada](#location)
O valor de `$uri` pode mudar durante o processamento da requisição, por exemplo, ao reescrever com [rewrite](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#id5), ao fazer redirecionamentos internos ou ao usar arquivos de índice. Veja [Escolhendo localizações](https://pt.angie.software//angie/docs/configuration/processing.md#pick-location) para como o valor é mapeado para um caminho no sistema de arquivos.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_access.md
# Access
O módulo controla o acesso aos recursos do servidor com base em endereços IP de clientes ou
redes. Ele permite permitir ou bloquear o acesso para endereços IP específicos,
faixas de IP ou sockets de domínio UNIX para melhorar a segurança restringindo o acesso a
áreas sensíveis de um site ou aplicação.
O acesso também pode ser restrito usando uma senha com o módulo [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic) ou com base no resultado de uma subrequisição com o
módulo [Auth Request](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request). Para aplicar tanto restrições de endereço quanto
de senha ao mesmo tempo, use a diretiva [satisfy](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Exemplo de Configuração
```nginx
location / {
deny 192.168.1.1;
allow 192.168.1.0/24;
allow 10.1.1.0/16;
allow 2001:0db8::/32;
deny all;
}
```
As regras são avaliadas sequencialmente até que uma correspondência seja encontrada. Neste exemplo, o acesso
é permitido apenas para as redes IPv4 `10.1.1.0/16` e
`192.168.1.0/24`, excluindo o endereço específico `192.168.1.1`, e
para a rede IPv6 `2001:0db8::/32`. Quando há muitas regras, é
preferível usar variáveis do módulo [Geo](https://pt.angie.software//angie/docs/configuration/modules/http/http_geo.md#http-geo).
## Diretivas
### allow
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `allow` address | CIDR | `unix:` | `all`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Permite acesso para uma rede ou endereço especificado.
O valor especial `all` significa todos os endereços IP de clientes.
O valor especial `unix:` permite acesso para quaisquer sockets de domínio UNIX.
### deny
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `deny` address | CIDR | `unix:` | `all`; |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Nega acesso para uma rede ou endereço especificado.
O valor especial `all` significa todos os endereços IP de clientes.
O valor especial `unix:` nega acesso para quaisquer sockets de domínio UNIX.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_acme.md
# ACME
Fornece recuperação automática de certificados usando o [protocolo ACME](https://datatracker.ietf.org/doc/html/rfc8555).
Ao [compilar a partir do código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild), o módulo não é compilado por padrão;
ele deve ser habilitado com a [opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure)
`--with-http_acme_module`.
Em pacotes e imagens de
[nossos repositórios](https://pt.angie.software//angie/docs/installation/index.md#install-packages),
o módulo está incluído na compilação.
## Exemplo de Configuração
Neste exemplo, um cliente ACME chamado `example` obtém e renova automaticamente um certificado para `example.com` e `www.example.com` usando a validação HTTP padrão:
```nginx
http {
resolver 127.0.0.53; # Necessário para a diretiva 'acme_client'
acme_client example https://acme-v02.api.letsencrypt.org/directory;
server {
listen 80; # Opcional se nenhum servidor escuta na porta de desafio HTTP
# (veja a diretiva 'acme_http_port')
listen 443 ssl;
server_name example.com www.example.com;
acme example;
ssl_certificate $acme_cert_example;
ssl_certificate_key $acme_cert_key_example;
}
}
```
Para outros métodos de validação (DNS, ALPN, baseada em hooks) e instruções de configuração detalhadas, consulte a seção [Configuração ACME](https://pt.angie.software//angie/docs/configuration/acme.md#acme-config).
## Diretivas
### acme
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme` name; |
|-------------------------------------------------------------------------------------------|----------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | server |
Especifica o [cliente ACME](#acme-client) que obtém um certificado
para os identificadores de certificado válidos neste bloco [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server).
Um único certificado cobre todos os nomes de domínio válidos e endereços IP
especificados nas diretivas [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name)
de todos os blocos [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server)
que referenciam o cliente com o name fornecido;
se a configuração `server_name` mudar,
o certificado é renovado para refletir as mudanças.
Cada vez que o Angie inicia, novos certificados são solicitados para todos os identificadores
que não possuem um certificado válido.
Possíveis razões incluem expiração do certificado,
arquivos ausentes ou ilegíveis,
e mudanças nas configurações do certificado.
#### NOTE
Esta diretiva controla apenas quais identificadores de certificado válidos
são incluídos nas solicitações de certificado;
ela não afeta onde o certificado pode ser usado.
Qualquer bloco `server` pode referenciar o certificado
através da variável [$acme_cert_](#v-acme-cert-name),
independentemente de o bloco conter ou não uma diretiva `acme`.
Remover `acme` de um bloco `server`
simplesmente exclui os valores de [server_name](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server-name) desse bloco
das futuras solicitações de certificado,
mas não impede que o bloco use o certificado.
#### NOTE
Atualmente, domínios especificados com expressões regulares
não são suportados e serão ignorados.
Domínios curinga são suportados apenas com `challenge=dns`
em `acme_client`.
Endereços IPv4 e IPv6 são suportados a menos que o cliente use
`challenge=dns`. Com a validação DNS habilitada, os endereços IP são ignorados.
Esta diretiva pode ser especificada múltiplas vezes
para carregar certificados de diferentes tipos, por exemplo RSA e ECDSA:
```nginx
server {
listen 443 ssl;
server_name example.com www.example.com;
ssl_certificate $acme_cert_rsa;
ssl_certificate_key $acme_cert_key_rsa;
ssl_certificate $acme_cert_ecdsa;
ssl_certificate_key $acme_cert_key_ecdsa;
acme rsa;
acme ecdsa;
}
```
### acme_client
#### Versionchanged
Alterado na versão 1.11.0.
#### Versionchanged
Alterado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_client` name uri [`enabled=``on` | `off`] [`key_type=`type] [`key_bits=`number] [`email=`email] [`max_cert_size=`number] [`max_key_auth_size=`size] [`renew_before_expiry=`time] [`renew_on_load`] [`retry_after_error=`off|time] [`challenge=``dns` | `http` | `alpn`] [`profile=`name] [`account_key=`file] [`eab=`id[:alg]:key]; |
|-------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define um cliente ACME com um name globalmente único.
Ele deve ser válido para um diretório,
é uma [string com variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables),
e será usado sem distinção entre maiúsculas e minúsculas.
Cada cliente gerencia um único certificado; para obter certificados separados,
configure múltiplos blocos `acme_client` (consulte
[Certificados Separados para Domínios Diferentes](https://pt.angie.software//angie/docs/configuration/acme.md#acme-config-multiple-clients)).
O segundo parâmetro obrigatório é o uri do diretório ACME.
Por exemplo, o URI do diretório ACME do Let's Encrypt é [especificado](https://letsencrypt.org/getting-started/)
como
[https://acme-v02.api.letsencrypt.org/directory](https://acme-v02.api.letsencrypt.org/directory).
#### NOTE
O módulo ACME adiciona um `location @acme` nomeado
ao contexto [client](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#client),
que pode ser usado para configurar solicitações ao diretório ACME;
por padrão, este `location`
contém uma diretiva [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass) com o uri do diretório,
ao qual outras configurações do módulo [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) podem ser adicionadas.
Para que esta diretiva funcione,
um [resolver](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver) deve ser configurado no mesmo contexto.
#### NOTE
Para fins de teste,
as autoridades certificadoras geralmente fornecem ambientes de teste separados.
Por exemplo, o [ambiente de teste do Let's Encrypt](https://letsencrypt.org/docs/staging-environment/)
é
[https://acme-staging-v02.api.letsencrypt.org/directory](https://acme-staging-v02.api.letsencrypt.org/directory).
| `enabled` | Habilita ou desabilita a renovação de certificados para o cliente; isso é útil, por exemplo, para suspender temporariamente sem remover o cliente da configuração.
Padrão: `on`. |
|-----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `key_type` | O tipo de algoritmo de chave privada para o certificado. Valores válidos: `rsa`, `ecdsa`.
Padrão: `ecdsa`. |
| `key_bits` | Número de bits na chave do certificado. Padrão: 256 para `ecdsa`, 2048 para `rsa`. |
| `email` | Endereço de email opcional para feedback; usado ao criar uma conta no servidor da CA. |
| `max_cert_size` | Especifica o tamanho máximo permitido de um novo arquivo de certificado em bytes para reservar espaço para o novo certificado na memória compartilhada; quanto mais domínios o certificado for solicitado, mais espaço será necessário. Este parâmetro não limita o tamanho das respostas do servidor ACME; use [acme_max_response_size](#acme-max-response-size) para isso.
Se o parâmetro não for definido, o Angie calcula um tamanho aproximado com base na lista de domínios configurada e o usa para alocação de memória compartilhada.
Se um certificado já existir na inicialização mas seu tamanho exceder o valor `max_cert_size`, o valor `max_cert_size` é aumentado dinamicamente para corresponder ao tamanho do arquivo de certificado existente.
Se o tamanho de um certificado obtido durante a renovação exceder `max_cert_size`, o processo de renovação falhará com um erro.
Padrão: calculado automaticamente. |
| `max_key_auth_size` | Limita o tamanho da string de autorização de chave que o Angie armazena na memória compartilhada para um desafio ACME. Se o servidor ACME retornar uma string de autorização de chave maior que este valor, a solicitação falhará com um erro que recomenda aumentar `max_key_auth_size`.
Embora especificado na linha `acme_client`, esta é uma configuração única compartilhada por todos os clientes no bloco `http`.
Padrão: `2k`. |
| `renew_before_expiry` | [Tempo](https://pt.angie.software//angie/docs/configuration/configfile.md#syntax) antes da expiração do certificado quando a renovação deve começar.
Padrão: `30d`. |
| `renew_on_load` | Especifica que o certificado deve ser renovado forçadamente cada vez que a configuração for carregada. |
| `retry_after_error` | [Tempo](https://pt.angie.software//angie/docs/configuration/configfile.md#syntax) para aguardar antes de tentar novamente se a recuperação do certificado falhar. Se definido como `off`, o cliente não tentará obter o certificado novamente após um erro.
Padrão: `2h`. |
| `challenge` | Especifica o tipo de verificação para o cliente ACME. Valores válidos: `dns`, `http`, `alpn`.
O valor `alpn` habilita a validação [TLS-ALPN-01](https://datatracker.ietf.org/doc/rfc8737/) e requer que o Angie seja compilado com OpenSSL que suporte ALPN (não suportado com compilações BoringSSL ou AWS-LC).
Padrão: `http`. |
| `profile` | Solicita um perfil ACME específico da autoridade certificadora. Um perfil é uma variante, definida pela CA, das configurações de certificado e validação, por exemplo o tempo de vida do certificado ou quais tipos de identificadores podem ser solicitados.
Por exemplo, a Let's Encrypt descreve seus perfis disponíveis na [documentação de perfis](https://letsencrypt.org/docs/profiles/).
O servidor ACME deve anunciar esse perfil nos metadados de seu diretório; caso contrário, o cliente não conseguirá obter um certificado. |
| `account_key` | Especifica o caminho completo para um arquivo contendo uma chave em formato PEM. Isso é útil se você quiser usar uma chave de conta existente em vez de geração automática, ou se precisar usar uma chave para múltiplos clientes ACME.
Tipos de chave suportados:
- Chaves RSA com comprimentos que são múltiplos de 8, variando de 2048 a 8192 bits. - Chaves ECDSA com comprimentos de 256, 384 ou 521 bits.
Ao especificar o parâmetro `account_key`, certifique-se de que o arquivo de chave realmente existe. Se o arquivo estiver ausente, o Angie tentará criá-lo no caminho especificado.
Note que as chaves para clientes ACME são criadas na ordem em que os clientes correspondentes são mencionados na configuração nas diretivas [acme_client](#acme-client), [acme](#id1) ou [acme_hook](#acme-hook). Portanto, se um cliente deve usar uma chave criada para outro, esse outro cliente deve aparecer antes na configuração.
Além disso, as chaves são criadas apenas para clientes que têm o parâmetro `enabled=on` definido. |
| `eab` | Configura o [External Account Binding](https://datatracker.ietf.org/doc/html/rfc8555#section-7.3.4) (EAB), vinculando a conta ACME a uma conta já registrada na autoridade certificadora (CA).
O valor tem a forma `eab=`id[:alg]:key:
- id — o identificador de chave emitido pela CA. - alg — o algoritmo de assinatura HMAC usado para calcular a assinatura de vinculação: `HS256` (padrão), `HS384` ou `HS512`. - key — a chave MAC codificada em Base64URL associada ao id no lado da CA.
Se a CA exigir External Account Binding mas o parâmetro não estiver definido, o cliente informa um erro sem criar uma conta ACME. As credenciais EAB só são enviadas quando uma nova conta ACME é registrada; uma conta ACME existente é reutilizada como está. |
### acme_client_path
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_client_path` path; |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Substitui o path para o diretório de armazenamento de certificados e chaves,
definido durante a compilação usando o [parâmetro de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure)
`--http-acme-client-path`.
### acme_dns_port
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_dns_port` port | ip[:port] | [ip6][:port]; |
|-------------------------------------------------------------------------------------------|----------------------------------------------------|
| Padrão | `acme_dns_port 53;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Especifica a porta
que o módulo usa para lidar com consultas DNS do servidor ACME sobre UDP.
O número da porta deve estar no intervalo de 1 a 65535.
Especificar um endereço IP junto com uma porta opcional também é suportado.
Tanto endereços IPv4 na forma `ip:port`
quanto endereços IPv6 na forma `[ip6]:port` podem ser usados:
```nginx
acme_dns_port 8053;
acme_dns_port 127.0.0.1;
acme_dns_port [::1];
```
Para usar o número de porta 1024 ou inferior,
o processo mestre do Angie deve executar com privilégios de superusuário.
### acme_dns_ttl
#### Versionadded
Adicionado na versão 1.12.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_dns_ttl` number; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | `acme_dns_ttl 1;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Define o TTL, em segundos, dos registros TXT que o módulo retorna nas respostas
às consultas de [validação DNS](https://pt.angie.software//angie/docs/configuration/acme.md#acme-config-dns) dos servidores ACME.
Aceita valores de 0 a 2147483647, conforme a [RFC 2181](https://datatracker.ietf.org/doc/html/rfc2181#section-8).
### acme_hook
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_hook` name [uri]; |
|-------------------------------------------------------------------------------------------|---------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita a validação de domínio baseada em hooks
para o [cliente ACME](#acme-client) especificado por name.
Quando a emissão ou renovação de certificado requer verificação de domínio,
o Angie gera uma solicitação interna
para o `location` nomeado onde esta diretiva está colocada.
Como a solicitação é tratada depende inteiramente
das outras diretivas configuradas no mesmo `location`,
como [fastcgi_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-pass), [proxy_pass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-pass),
ou qualquer outro manipulador de solicitações.
| name | O nome do [cliente ACME](#acme-client) para o qual este hook trata a verificação de domínio. |
|--------|------------------------------------------------------------------------------------------------------------|
| uri | Uma string com variáveis; especifica a URI de solicitação para chamadas de hook.
Padrão: `/`. |
Por exemplo, a seguinte configuração passa os valores das [variáveis de hook](#http-acme-variables)
para uma aplicação FastCGI através da URI de solicitação:
```nginx
acme_hook example uri=/acme_hook/$acme_hook_name?domain=$acme_hook_domain&key=$acme_hook_keyauth;
fastcgi_param REQUEST_URI $request_uri;
fastcgi_pass ...;
```
### acme_http_port
#### Versionadded
Adicionado na versão 1.11.0.
#### Versionchanged
Alterado na versão 1.11.1.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_http_port` port | ip[:port] | [ip6][:port]; |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------|
| Padrão | `acme_http_port 80;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Especifica a porta
que o módulo usa para lidar com solicitações de desafio ACME HTTP.
O número da porta deve estar no intervalo de 1 a 65535.
Especificar um endereço IP junto com uma porta opcional também é suportado.
Tanto endereços IPv4 na forma `ip:port`
quanto endereços IPv6 na forma `[ip6]:port` podem ser usados:
```nginx
acme_http_port 8080;
acme_http_port 127.0.0.1;
acme_http_port [::1];
```
Se nenhum servidor estiver configurado para escutar no endereço e porta especificados,
o módulo cria um listener dedicado para desafios HTTP.
Para usar o número de porta 1024 ou inferior,
o processo mestre do Angie deve executar com privilégios de superusuário.
### acme_max_response_size
#### Versionadded
Adicionado na versão 1.11.0.
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `acme_max_response_size` size; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `acme_max_response_size 32k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Limita o tamanho máximo do corpo de uma resposta do servidor ACME. Se uma resposta exceder
este limite, a solicitação falhará com um erro. Aumente o valor se você ver
erros como `too big subrequest response while sending to client`.
## Variáveis Integradas
### `$acme_cert_`
Conteúdo do último arquivo de certificado (se houver)
obtido pelo cliente com este name.
### `$acme_cert_key_`
Conteúdo do arquivo de chave do certificado
usado pelo cliente com este name.
#### NOTE
O arquivo de certificado está disponível
apenas se o cliente ACME tiver obtido pelo menos um certificado,
mas o arquivo de chave está disponível imediatamente após a inicialização.
### `$acme_hook_challenge`
O tipo de desafio. Valores possíveis: `dns`, `http`, `alpn`.
### `$acme_hook_client`
O nome do cliente ACME que inicia a solicitação.
### `$acme_hook_domain`
O domínio sendo verificado.
Se for um domínio curinga, será passado sem o prefixo `*.`.
### `$acme_hook_keyauth`
A string de autorização:
- Para desafio DNS, é usada como o valor do registro TXT,
cujo nome é formado como
`_acme-challenge. + $acme_hook_domain + .`.
- Para desafio HTTP, esta string deve ser usada
como o conteúdo da resposta solicitada pelo servidor ACME.
### `$acme_hook_name`
O nome do hook. Para diferentes tipos de desafio, pode ter diferentes valores e significados:
| Valor | Significado para desafio DNS | Significado para desafio HTTP |
|----------------------------|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
| `add` (hook de adição) | O registro TXT correspondente deve ser adicionado à configuração DNS. | Uma resposta à solicitação HTTP correspondente deve ser preparada. |
| `remove` (hook de remoção) | O registro TXT pode ser removido da configuração DNS. | Esta solicitação HTTP não é mais relevante; o arquivo criado anteriormente com a string de autorização pode ser removido. |
### `$acme_hook_token`
O token de verificação.
Para desafio HTTP, é usado como o nome do arquivo solicitado:
`/.well-known/acme-challenge/` + `$acme_hook_token`.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_addition.md
# Addition
O módulo é um filtro que adiciona texto antes e depois de uma resposta.
Ao [compilar a partir do código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo não é compilado por padrão;
ele deve ser habilitado com a
`‑‑with‑http_addition_module`
[opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure).
Em pacotes e imagens dos [nossos repositórios](https://pt.angie.software//angie/docs/installation/index.md#install-packages),
o módulo está incluído na compilação.
## Exemplo de Configuração
```nginx
location / {
add_before_body /before_action;
add_after_body /after_action;
}
```
## Diretivas
### add_after_body
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `add_after_body` uri; |
|-------------------------------------------------------------------------------------------|-------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Adiciona o texto retornado como resultado do processamento de uma determinada sub-requisição após o corpo da resposta. Uma string vazia (`""`) como parâmetro cancela a adição herdada do nível de configuração anterior.
### add_before_body
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `add_before_body` uri; |
|-------------------------------------------------------------------------------------------|--------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Adiciona o texto retornado como resultado do processamento de uma determinada sub-requisição antes do corpo da resposta. Uma string vazia (`""`) como parâmetro cancela a adição herdada do nível de configuração anterior.
### addition_types
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `addition_types` mime-type ...; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | `addition_types text/html;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite adicionar texto em respostas com os tipos MIME especificados, além de "text/html". O valor especial "\*" corresponde a qualquer tipo MIME.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_api.md
# API
O módulo `API` implementa uma interface HTTP RESTful para obter informações básicas
sobre o servidor web em formato JSON, bem como [estatísticas](#metrics) sobre conexões
de clientes, zonas de memória compartilhada, consultas DNS, requisições HTTP, cache de resposta HTTP,
sessões do módulo [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#stream-core) e zonas dos módulos
[limit_conn http](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_conn.md#http-limit-conn), [limit_conn stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#stream-limit-conn), [limit_req](https://pt.angie.software//angie/docs/configuration/modules/http/http_limit_req.md#http-limit-req) e [http upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream), bem como informações sobre os certificados especificados na configuração e obtidos por clientes ACME.
#### NOTE
Veja um exemplo ao vivo da saída da API em
[https://console.angie.software/api/](https://console.angie.software/api/).
A interface aceita os métodos HTTP `GET` e `HEAD`;
uma requisição com outro método causará um erro:
```json
{
"error": "MethodNotAllowed",
"description": "The POST method is not allowed for the requested API element \"/\"."
}
```
No Angie PRO, esta interface inclui uma seção de [configuração dinâmica](#api-config) que permite alterar configurações sem recarregar a configuração ou
reiniciar; atualmente, a configuração de servidores individuais dentro de
[upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) está disponível.
## Diretivas
### api
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `api` path; |
|-------------------------------------------------------------------------------------------|---------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita a interface HTTP RESTful em `location`.
O parâmetro path é obrigatório. Similar à diretiva [alias](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#alias), ele define o caminho para substituir aquele especificado em `location`, mas sobre a árvore da API ao invés do sistema de arquivos.
Se especificado em um `location` de prefixo:
```nginx
location /stats/ {
api /status/http/server_zones/;
}
```
a parte da URI da requisição que corresponde ao prefixo /stats/ será substituída pelo caminho especificado no parâmetro path: /status/http/server_zones/. Por exemplo, uma requisição para /stats/foo/ acessará o elemento da API `/status/http/server_zones/foo/`.
[Variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables) são permitidas: api /status/$module/server_zones/$name/ e uso dentro de location regex:
```nginx
location ~^/api/([^/]+)/(.*)$ {
api /status/http/$1_zones/$2;
}
```
Aqui o parâmetro path define o caminho completo para o elemento da API;
assim, de uma requisição para `/api/location/data/` as seguintes variáveis serão extraídas:
```console
$1 = "location"
$2 = "data/"
```
E a requisição final será `/status/http/location_zones/data/`.
#### NOTE
No Angie PRO, você pode separar a [API de configuração dinâmica](#api-config) e a [API de status](#metrics) imutável que reflete
o estado atual:
```nginx
location /config/ {
api /config/;
}
location /status/ {
api /status/;
}
```
O parâmetro path também permite controlar o acesso à API:
```nginx
location /status/ {
api /status/;
allow 127.0.0.1;
deny all;
}
```
Ou:
```nginx
location /blog/requests/ {
api /status/http/server_zones/blog/requests/;
auth_basic "blog";
auth_basic_user_file conf/htpasswd;
}
```
#### NOTE
Se `api` for colocado em um `location` com uma barra final no prefixo
(por exemplo, `location /name/`),
e a diretiva [auto_redirect](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#auto-redirect) estiver definida como `default`,
requisições sem uma barra final serão redirecionadas (`/name -> /name/`).
### api_config_files
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `api_config_files` `on` | `off`; |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão | off |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | location |
Habilita ou desabilita a adição do objeto `config_files`,
que lista o conteúdo de todos os arquivos de configuração do Angie
atualmente carregados pela instância do servidor,
à seção da API [/status/angie/](#status-angie).
Por exemplo, com esta configuração:
```nginx
location /status/ {
api /status/;
api_config_files on;
}
```
Uma requisição para `/status/angie/` retorna aproximadamente o seguinte:
```json
{
"version":"1.12.1",
"address":"192.168.16.5",
"generation":1,
"load_time":"2026-07-17T12:58:39.789Z",
"config_files": {
"/etc/angie/angie.conf": "...",
"/etc/angie/mime.types": "..."
}
}
```
Por padrão, a saída está desabilitada porque os arquivos de configuração podem conter
informações particularmente sensíveis e confidenciais.
## Métricas
O Angie publica estatísticas de uso na seção da API `/status/`; você pode
abrir acesso a ela definindo o `location` apropriado. Acesso completo:
```nginx
location /status/ {
api /status/;
}
```
Exemplo de acesso parcial, já mostrado acima:
```nginx
location /stats/ {
api /status/http/server_zones/;
}
```
### Exemplo de configuração
Com uma configuração incluindo `location /status/`, `resolver`, `http` em
`upstream`, `http server`, `location`, `cache`, `limit_conn` em
`http` e zonas `limit_req`:
```nginx
http {
resolver 127.0.0.53 status_zone=resolver_zone;
proxy_cache_path /var/cache/angie/cache keys_zone=cache_zone:2m;
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
server {
server_name www.example.com;
listen 443 ssl;
status_zone http_server_zone;
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
access_log /var/log/access.log main;
location / {
root /usr/share/angie/html;
status_zone location_zone;
limit_conn limit_conn_zone 1;
limit_req zone=limit_req_zone burst=5;
}
location /status/ {
api /status/;
allow 127.0.0.1;
deny all;
}
}
}
```
Em resposta à requisição `curl https://www.example.com/status/`, o Angie retorna:
### Árvore JSON
```json
{
"angie": {
"version":"1.12.1",
"address":"192.168.16.5",
"generation":1,
"load_time":"2026-07-17T12:58:39.789Z"
},
"connections": {
"accepted":2257,
"dropped":0,
"active":3,
"idle":1
},
"slabs": {
"cache_zone": {
"pages": {
"used":2,
"free":506
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":1,
"fails":0
},
"512": {
"used":1,
"free":7,
"reqs":1,
"fails":0
}
}
},
"limit_conn_zone": {
"pages": {
"used":2,
"free":2542
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":74,
"fails":0
},
"128": {
"used":1,
"free":31,
"reqs":1,
"fails":0
}
}
},
"limit_req_zone": {
"pages": {
"used":2,
"free":2542
},
"slots": {
"64": {
"used":1,
"free":63,
"reqs":1,
"fails":0
},
"128": {
"used":2,
"free":30,
"reqs":3,
"fails":0
}
}
}
},
"http": {
"server_zones": {
"http_server_zone": {
"ssl": {
"handshaked":4174,
"reuses":0,
"timedout":0,
"failed":0
},
"requests": {
"total":4327,
"processing":0,
"discarded":8
},
"responses": {
"200":4305,
"302":12,
"404":4
},
"data": {
"received":733955,
"sent":59207757
}
}
},
"location_zones": {
"location_zone": {
"requests": {
"total":4158,
"discarded":0
},
"responses": {
"200":4157,
"304":1
},
"data": {
"received":538200,
"sent":177606236
}
}
},
"caches": {
"cache_zone": {
"size":0,
"cold":false,
"hit": {
"responses":0,
"bytes":0
},
"stale": {
"responses":0,
"bytes":0
},
"updating": {
"responses":0,
"bytes":0
},
"revalidated": {
"responses":0,
"bytes":0
},
"miss": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
},
"expired": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
},
"bypass": {
"responses":0,
"bytes":0,
"responses_written":0,
"bytes_written":0
}
}
},
"limit_conns": {
"limit_conn_zone": {
"passed":73,
"skipped":0,
"rejected":0,
"exhausted":0
}
},
"limit_reqs": {
"limit_req_zone": {
"passed":54816,
"skipped":0,
"delayed":65,
"rejected":26,
"exhausted":0
}
},
"upstreams": {
"upstream": {
"peers": {
"192.168.16.4:80": {
"server":"backend.example.com",
"service":"_example._tcp",
"backup":false,
"weight":5,
"state":"up",
"selected": {
"current":2,
"total":232
},
"max_conns":5,
"responses": {
"200":222,
"302":12
},
"data": {
"sent":543866,
"received":27349934
},
"health": {
"fails":0,
"unavailable":0,
"downtime":0
},
"sid":""
}
},
"keepalive":2
}
}
},
"resolvers": {
"resolver_zone": {
"queries": {
"name":442,
"srv":2,
"addr":0
},
"responses": {
"success":440,
"timedout":1,
"format_error":0,
"server_failure":1,
"not_found":1,
"unimplemented":0,
"refused":1,
"other":0
}
}
}
}
```
Um conjunto de métricas pode ser solicitado por ramo JSON individual construindo a requisição apropriada. Por exemplo:
```console
$ curl https://www.example.com/status/angie
$ curl https://www.example.com/status/connections
$ curl https://www.example.com/status/slabs
$ curl https://www.example.com/status/slabs//slots
$ curl https://www.example.com/status/slabs//slots/64
$ curl https://www.example.com/status/http/
$ curl https://www.example.com/status/http/acme_clients
$ curl https://www.example.com/status/http/acme_clients/
$ curl https://www.example.com/status/http/metric_zones
$ curl https://www.example.com/status/http/metric_zones//metrics
$ curl https://www.example.com/status/http/server_zones
$ curl https://www.example.com/status/http/server_zones/
$ curl https://www.example.com/status/http/server_zones//ssl
```
### Argumentos da query string
Os seguintes argumentos da query string modificam as respostas JSON da API:
`pretty`
: Por padrão, a API formata as respostas JSON com recuo e quebras de linha.
Para obter uma saída compacta de uma única linha, adicione `pretty=off`
à query string:
```console
$ curl https://www.example.com/status/connections?pretty=off
{"accepted":2257,"dropped":0,"active":3,"idle":1}
```
`date`
: Por padrão, o módulo usa strings de formato ISO 8601 para datas; para usar o
formato inteiro UNIX epoch em vez disso, adicione o parâmetro
`date=epoch` à query string:
```console
$ curl https://www.example.com/status/angie/load_time
"2024-04-01T00:59:59+01:00"
$ curl https://www.example.com/status/angie/load_time?date=epoch
1711929599
```
`defaults` (PRO)
: Você pode obter valores de parâmetros padrão com o argumento `defaults=on`:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers?defaults=on
```
```json
{
"backend.example.com": {
"weight": 1,
"max_conns": 5,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": false,
"down": false,
"sid": ""
}
}
```
### Status do servidor
#### `/status/angie`
```json
{
"version": "1.12.1",
"build_time": "2026-07-17T16:05:43.805Z",
"address": "192.168.16.5",
"generation": 1,
"load_time": "2026-07-17T16:15:43.805Z"
"config_files": {
"/etc/angie/angie.conf": "...",
"/etc/angie/mime.types": "..."
}
}
```
| `version` | String; versão do servidor web Angie em execução |
|----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `build` | String; nome específico da build se especificado durante a compilação |
| `build_time` | String; o tempo de build do executável Angie no formato de [data](#api-date-format) |
| `address` | String; o endereço do servidor que aceitou a requisição da API |
| `generation` | Number; número total de recarregamentos de configuração desde o último início |
| `load_time` | String; tempo do último recarregamento de configuração no formato de [data](#api-date-format); valores string têm resolução de milissegundos |
| `config_files` | Object; seus membros são nomes de caminho absolutos de todos os arquivos de configuração do Angie que estão atualmente carregados pela instância do servidor, e seus valores são representações string do conteúdo dos arquivos, por exemplo:
#### WARNING O objeto `config_files` está disponível em `/status/angie/` apenas se a diretiva [api_config_files](#a-api-config-files) estiver habilitada. |
#### `/status/angie/license` (PRO)
#### Versionadded
Adicionado na versão 1.11.0: PRO
```json
{
"path": "/etc/angie/license.pem",
"status": "valid",
"owner": "Example Corp",
"days_left": 30,
"since": "2026-01-01",
"until": "2027-01-01",
"limits": {
"worker_processes": 16,
"worker_connections": 65535
}
}
```
| `path` | String; caminho completo para o arquivo de licença |
|-------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
| `status` | String; status da licença: `missing`, `invalid`, `valid`, `grace`, `expired`, ou `pending` |
| `owner` | String; proprietário da licença do assunto do certificado |
| `days_left` | Number; dias até que a licença mude de estado. Um valor negativo significa que a licença expirou, e o valor é o número de dias desde a expiração |
| `since` | String; data de início de validade da licença |
| `until` | String; data de término de validade da licença |
| `limits` | Object; limites licenciados para a instância atual |
### Conexões
#### `/status/connections`
```json
{
"accepted": 2257,
"dropped": 0,
"active": 3,
"idle": 1
}
```
| `accepted` | Number; o número total de conexões de cliente aceitas |
|--------------|-----------------------------------------------------------|
| `dropped` | Number; o número total de conexões de cliente descartadas |
| `active` | Number; o número atual de conexões de cliente ativas |
| `idle` | Number; o número atual de conexões de cliente ociosas |
### Zonas de memória compartilhada com alocação slab
#### `/status/slabs/`
Estatísticas de uso de zonas de memória compartilhada que utilizam [alocação slab](https://en.wikipedia.org/wiki/Slab_allocation). Qualquer zona que utilize
alocação slab é informada, incluindo as de [limit_conn](#limit-conn),
[limit_req](#limit-req) e [cache HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache), bem como a zona
de memória compartilhada de um upstream [HTTP](#a-upstream) ou
[stream](#a-s-upstream):
```nginx
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
```
A zona de memória compartilhada especificada coletará as seguintes estatísticas:
| `pages` | Object; estatísticas de páginas de memória |
|-----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `used` | Number; o número de páginas de memória atualmente em uso |
| `free` | Number; o número de páginas de memória atualmente livres |
| `slots` | Object; estatísticas de slots de memória para cada tamanho de slot. O objeto `slots` contém dados para tamanhos de slot de memória (`8`, `16`, `32`, etc., até metade do tamanho da página em bytes) |
| `used` | Number; o número de slots de memória atualmente em uso do tamanho especificado |
| `free` | Number; o número de slots de memória atualmente livres do tamanho especificado |
| `reqs` | Number; o número total de tentativas de alocar memória do tamanho especificado |
| `fails` | Number; o número de tentativas malsucedidas de alocar memória do tamanho especificado |
Exemplo:
```json
{
"pages": {
"used": 2,
"free": 506
},
"slots": {
"64": {
"used": 1,
"free": 63,
"reqs": 1,
"fails": 0
}
}
```
### Consultas DNS ao resolver
#### `/status/resolvers/`
Para coletar estatísticas do resolver,
a diretiva [resolver](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver) deve definir o parâmetro `status_zone`
([HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver-status) ou [Stream](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-resolver-status)):
```nginx
resolver 127.0.0.53 status_zone=resolver_zone;
```
A zona de memória compartilhada especificada coletará as seguintes estatísticas:
| `queries` | Object; estatísticas de consultas |
|------------------|-------------------------------------------------------------------------------------------|
| `name` | Number; o número de consultas para resolver nomes para endereços (consultas A e AAAA) |
| `srv` | Number; o número de consultas para resolver serviços para endereços (consultas SRV) |
| `addr` | Number; o número de consultas para resolver endereços para nomes (consultas PTR) |
| `responses` | Object; estatísticas de respostas |
| `success` | Number; o número de respostas bem-sucedidas |
| `timedout` | Number; o número de consultas que expiraram |
| `format_error` | Number; o número de respostas com código 1 (Format Error) |
| `server_failure` | Number; o número de respostas com código 2 (Server Failure) |
| `not_found` | Number; o número de respostas com código 3 (Name Error) |
| `unimplemented` | Number; o número de respostas com código 4 (Not Implemented) |
| `refused` | Number; o número de respostas com código 5 (Refused) |
| `other` | Number; o número de consultas completadas com outro código não-zero |
| `sent` | Object; estatísticas de consultas DNS enviadas |
| `a` | Number; o número de consultas do tipo A |
| `aaaa` | Number; o número de consultas do tipo AAAA |
| `ptr` | Number; o número de consultas do tipo PTR |
| `srv` | Number; o número de consultas do tipo SRV |
#### NOTE
`queries` e `responses` contabilizam cada solicitação de resolução
que o Angie faz internamente, incluindo as servidas pelo cache TTL.
`sent` contabiliza os pacotes efetivamente enviados ao servidor de nomes;
a diferença entre os dois reflete os acertos de cache.
Os códigos de resposta são descritos na [RFC 1035](https://datatracker.ietf.org/doc/html/rfc1035.html), seção [4.1.1](https://datatracker.ietf.org/doc/html/rfc1035.html#section-4.1.1).
Vários tipos de registro DNS são detalhados na [RFC 1035](https://datatracker.ietf.org/doc/html/rfc1035.html),
[RFC 2782](https://datatracker.ietf.org/doc/html/rfc2782.html), e
[RFC 3596](https://datatracker.ietf.org/doc/html/rfc3596.html).
Exemplo:
```json
{
"queries": {
"name": 442,
"srv": 2,
"addr": 0
},
"responses": {
"success": 440,
"timedout": 1,
"format_error": 0,
"server_failure": 1,
"not_found": 1,
"unimplemented": 0,
"refused": 1,
"other": 0
},
"sent": {
"a": 185,
"aaaa": 245,
"srv": 2,
"ptr": 12
}
}
```
### Servidor HTTP e localização
#### `/status/http/server_zones/`
Para coletar as métricas do `server`,
defina a diretiva [status_zone](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#status-zone) no contexto [server](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#server):
```nginx
server {
...
status_zone server_zone;
}
```
Para agrupar as métricas por um valor personalizado, use a sintaxe alternativa.
Aqui, as métricas são agregadas por [$host](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#v-host),
com cada grupo relatado como uma zona independente:
```nginx
status_zone $host zone=server_zone:5;
```
A zona de memória compartilhada especificada coletará as seguintes estatísticas:
| `ssl` | Object; estatísticas SSL. Presente se `server` definir `listen ssl;` |
|--------------|--------------------------------------------------------------------------------------|
| `handshaked` | Number; o número total de handshakes SSL bem-sucedidos |
| `reuses` | Number; o número total de reutilizações de sessão durante o handshake SSL |
| `timedout` | Number; o número total de handshakes SSL que expiraram |
| `failed` | Number; o número total de handshakes SSL que falharam |
| `requests` | Object; estatísticas de requisições |
| `total` | Number; o número total de requisições de clientes |
| `processing` | Number; o número de requisições de clientes sendo processadas atualmente |
| `discarded` | Number; o número total de requisições de clientes concluídas sem enviar uma resposta |
| `responses` | Object; estatísticas de respostas |
| `` | Number; um número não-zero de respostas com status (100-599) |
| `xxx` | Number; um número não-zero de respostas com outros códigos de status |
| `data` | Object; estatísticas de dados |
| `received` | Number; o número total de bytes recebidos de clientes |
| `sent` | Number; o número total de bytes enviados para clientes |
#### NOTE
Os contadores `responses` registram apenas respostas reais, ou
seja, aquelas que foram efetivamente enviadas ao cliente. Uma requisição
cujo processamento terminou sem enviar uma resposta é contabilizada em
`discarded` e não incrementa os contadores `responses`. Em
particular, `499` não é uma resposta, mas um código de serviço
interno, registrado apenas no log de acesso, que marca uma requisição
cujo processamento terminou sem que uma resposta fosse enviada; tais
requisições são refletidas em `discarded`, nunca em
`responses`.
Exemplo:
```json
{
"ssl":{
"handshaked":4174,
"reuses":0,
"timedout":0,
"failed":0
},
"requests":{
"total":4327,
"processing":0,
"discarded":0
},
"responses":{
"200":4305,
"302":6,
"304":12,
"404":4
},
"data":{
"received":733955,
"sent":59207757
}
}
```
#### `/status/http/location_zones/`
Para coletar as métricas do `location`, defina a diretiva [status_zone](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#status-zone)
no contexto de [location](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#location) ou [if in location](https://pt.angie.software//angie/docs/configuration/modules/http/http_rewrite.md#if):
```nginx
location / {
root /usr/share/angie/html;
status_zone location_zone;
if ($request_uri ~* "^/condition") {
# ...
status_zone if_location_zone;
}
}
```
Para agrupar as métricas por um valor personalizado, use a sintaxe alternativa.
Aqui, as métricas são agregadas por [$host](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#v-host),
com cada grupo relatado como uma zona independente:
```nginx
status_zone $host zone=server_zone:5;
```
A zona de memória compartilhada especificada coletará as seguintes estatísticas:
| `requests` | Object; estatísticas de requisições |
|--------------|--------------------------------------------------------------------------------------|
| `total` | Number; o número total de requisições de clientes |
| `discarded` | Number; o número total de requisições de clientes concluídas sem enviar uma resposta |
| `responses` | Object; estatísticas de respostas |
| `` | Number; um número não-zero de respostas com status (100-599) |
| `xxx` | Number; um número não-zero de respostas com outros códigos de status |
| `data` | Object; estatísticas de dados |
| `received` | Number; o número total de bytes recebidos de clientes |
| `sent` | Number; o número total de bytes enviados para clientes |
#### NOTE
Os contadores `responses` registram apenas respostas reais, ou
seja, aquelas que foram efetivamente enviadas ao cliente. Uma requisição
cujo processamento terminou sem enviar uma resposta é contabilizada em
`discarded` e não incrementa os contadores `responses`. Em
particular, `499` não é uma resposta, mas um código de serviço
interno, registrado apenas no log de acesso, que marca uma requisição
cujo processamento terminou sem que uma resposta fosse enviada; tais
requisições são refletidas em `discarded`, nunca em
`responses`.
Exemplo:
```json
{
"requests": {
"total": 4158,
"discarded": 0
},
"responses": {
"200": 4157,
"304": 1
},
"data": {
"received": 538200,
"sent": 177606236
}
}
```
#### `/status/http/metric_zones/`
Métricas personalizadas definidas por [metric_zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#metric-zone) ou [metric_complex_zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#metric-complex-zone)
no contexto `http`. As métricas são atualizadas com a diretiva [metric](https://pt.angie.software//angie/docs/configuration/modules/http/http_metric.md#id1)
ou as variáveis do módulo.
| `discarded` | Number; o número de entradas de métricas descartadas porque a zona ficou sem memória. |
|---------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `metrics` | Object; métricas por chave. Para zonas de métrica única, os valores são números. Para zonas complexas, os valores são objetos com nomes de métricas. Para o modo histograma, os valores são objetos com nomes de buckets. |
Se `discard_key` estiver definido e algumas entradas tiverem expirado,
suas métricas agregadas são expostas sob esta chave.
Exemplo:
```json
{
"discarded": 3,
"metrics": {
"example.com": {
"count": 42,
"max": 8
}
"expired": {
"count": 10,
"max": 3.2
}
}
}
```
### Servidor stream
#### `/status/stream/server_zones/`
Para coletar as métricas do `server`,
defina a diretiva [status_zone](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-status-zone) no contexto [server](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#s-server):
```nginx
server {
...
status_zone server_zone;
}
```
Para agrupar as métricas por um valor personalizado, use a sintaxe alternativa.
Aqui, as métricas são agregadas por [$server_addr](https://pt.angie.software//angie/docs/configuration/modules/stream/index.md#v-s-server-addr),
com cada grupo relatado como uma zona independente:
```nginx
status_zone $server_addr zone=server_zone:5;
```
A zona de memória compartilhada especificada coletará as seguintes estatísticas:
| `ssl` | Object; estatísticas SSL. Presente se `server` definir `listen ssl;` |
|-----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `handshaked` | Number; o número total de handshakes SSL bem-sucedidos |
| `reuses` | Number; o número total de reutilizações de sessão durante o handshake SSL |
| `timedout` | Number; o número total de handshakes SSL que expiraram |
| `failed` | Number; o número total de handshakes SSL que falharam |
| `connections` | Object; estatísticas de conexões |
| `total` | Number; o número total de conexões de clientes |
| `processing` | Number; o número de conexões de clientes sendo processadas atualmente |
| `discarded` | Number; o número total de conexões de clientes concluídas sem criar uma sessão |
| `passed` | Number; o número total de conexões de clientes redirecionadas para outra porta de escuta com diretivas `pass` |
| `sessions` | Object; estatísticas de sessões |
| `success` | Number; o número de sessões concluídas com código 200, que significa conclusão bem-sucedida |
| `invalid` | Number; o número de sessões concluídas com código 400, que acontece quando os dados do cliente não puderam ser analisados, por exemplo, o cabeçalho do protocolo PROXY |
| `forbidden` | Number; o número de sessões concluídas com código 403, quando o acesso foi proibido, por exemplo, quando o acesso é limitado para determinados endereços de clientes |
| `internal_error` | Number; o número de sessões concluídas com código 500, erro interno do servidor |
| `bad_gateway` | Number; o número de sessões concluídas com código 502, gateway inválido, por exemplo, se um servidor upstream não pôde ser selecionado ou alcançado |
| `service_unavailable` | Number; o número de sessões concluídas com código 503, serviço indisponível, por exemplo, quando o acesso é limitado pelo número de conexões |
| `data` | Object; estatísticas de dados |
| `received` | Number; o número total de bytes recebidos de clientes |
| `sent` | Number; o número total de bytes enviados para clientes |
Exemplo:
```json
{
"ssl": {
"handshaked": 24,
"reuses": 0,
"timedout": 0,
"failed": 0
},
"connections": {
"total": 24,
"processing": 1,
"discarded": 0,
"passed": 2
},
"sessions": {
"success": 24,
"invalid": 0,
"forbidden": 0,
"internal_error": 0,
"bad_gateway": 0,
"service_unavailable": 0
},
"data": {
"received": 2762947,
"sent": 53495723
}
}
```
#### `/status/stream/metric_zones/`
Métricas personalizadas definidas por [metric_zone](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric-zone) ou
[metric_complex_zone](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric-complex-zone) no contexto `stream`.
As métricas são atualizadas com a diretiva [metric](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_metric.md#s-metric) ou com as
variáveis do módulo.
| `discarded` | Número; o número de entradas de métricas descartadas porque a zona ficou sem memória. |
|---------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `metrics` | Objeto; métricas por chave. Para zonas de métrica única, os valores são números. Para zonas complexas, os valores são objetos com nomes de métricas. Para o modo histograma, os valores são objetos com nomes de bucket. |
Se `discard_key` estiver configurado e algumas entradas tiverem expirado,
suas métricas agregadas são expostas sob esta chave.
Exemplo:
```json
{
"discarded": 3,
"metrics": {
"127.0.0.1": {
"count": 42,
"max": 8
},
"expired": {
"count": 10,
"max": 3.2
}
}
}
```
### Caches HTTP
```nginx
proxy_cache cache_zone;
proxy_cache_valid 200 10m;
```
#### `/status/http/caches/`
Para cada zona configurada com [proxy_cache](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache), os seguintes dados são
armazenados:
```json
{
"name_zone": {
"size": 0,
"cold": false,
"hit": {
"responses": 0,
"bytes": 0
},
"stale": {
"responses": 0,
"bytes": 0
},
"updating": {
"responses": 0,
"bytes": 0
},
"revalidated": {
"responses": 0,
"bytes": 0
},
"miss": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
},
"expired": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
},
"bypass": {
"responses": 0,
"bytes": 0,
"responses_written": 0,
"bytes_written": 0
}
}
}
```
| `size` | Número; o tamanho atual do cache |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `max_size` | Número; limite configurado para o tamanho máximo do cache |
| `cold` | Booleano; `true` enquanto o cache loader carrega dados do disco |
| `hit` | Objeto; estatísticas de respostas válidas em cache ([proxy_cache_valid](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-valid)) |
| `responses` | Número; o número total de respostas lidas do cache |
| `bytes` | Número; o número total de bytes lidos do cache |
| `stale` | Objeto; estatísticas de respostas obsoletas obtidas do cache ([proxy_cache_use_stale](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-use-stale)) |
| `responses` | Número; o número total de respostas lidas do cache |
| `bytes` | Número; o número total de bytes lidos do cache |
| `updating` | Objeto; estatísticas de respostas obsoletas obtidas do cache enquanto as respostas estavam sendo atualizadas ([proxy_cache_use_stale](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-use-stale) updating) |
| `responses` | Número; o número total de respostas lidas do cache |
| `bytes` | Número; o número total de bytes lidos do cache |
| `revalidated` | Objeto; estatísticas de respostas expiradas e revalidadas obtidas do cache ([proxy_cache_revalidate](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-revalidate)) |
| `responses` | Número; o número total de respostas lidas do cache |
| `bytes` | Número; o número total de bytes lidos do cache |
| `miss` | Objeto; estatísticas de respostas não encontradas no cache |
| `responses` | Número; o número total de respostas correspondentes |
| `bytes` | Número; o número total de bytes lidos do servidor com proxy |
| `responses_written` | Número; o número total de respostas escritas no cache |
| `bytes_written` | Número; o número total de bytes escritos no cache |
| `expired` | Objeto; estatísticas de respostas expiradas não obtidas do cache |
| `responses` | Número; o número total de respostas correspondentes |
| `bytes` | Número; o número total de bytes lidos do servidor com proxy |
| `responses_written` | Número; o número total de respostas escritas no cache |
| `bytes_written` | Número; o número total de bytes escritos no cache |
| `bypass` | Objeto; estatísticas de respostas não consultadas no cache ([proxy_cache_bypass](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-bypass)) |
| `responses` | Número; o número total de respostas correspondentes |
| `bytes` | Número; o número total de bytes lidos do servidor com proxy |
| `responses_written` | Número; o número total de respostas escritas no cache |
| `bytes_written` | Número; o número total de bytes escritos no cache |
No Angie PRO, se o cache sharding estiver habilitado com diretivas [proxy_cache_path](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-cache-path),
fragmentos individuais são expostos como membros de objeto de um objeto `shards`:
| `shards` | Objeto; lista fragmentos individuais como membros |
|------------|-------------------------------------------------------------------------------|
| `` | Objeto; representa um fragmento individual com seu caminho de cache como nome |
| `size` | Número; o tamanho atual do fragmento |
| `max_size` | Número; tamanho máximo do fragmento, se configurado |
| `cold` | Booleano; `true` enquanto o cache loader carrega dados do disco |
```json
{
"name_zone": {
"shards": {
"/path/to/shard1": {
"size": 0,
"cold": false
},
"/path/to/shard2": {
"size": 0,
"cold": false
}
}
}
```
### Clientes ACME
#### `/status/http/acme_clients/`
Para cada [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) configurado no bloco `http`, retorna o
status atual do cliente e do certificado:
```json
{
"state": "ready",
"certificate": "valid",
"details": "The client is ready to request a certificate.",
"next_run": "2026-07-17T16:15:43.805Z"
}
```
| `state` | String; estado do cliente ACME. Valores possíveis: `ready`, `requesting`, `disabled`, `failed`. |
|---------------|----------------------------------------------------------------------------------------------------------------------------------------------|
| `certificate` | String; status do certificado. Valores possíveis: `valid`, `expired`, `missing`, `mismatch`, `error`. |
| `details` | String; detalhes breves do status da última operação ACME. |
| `next_run` | Data; próxima tentativa agendada para solicitar ou renovar o certificado. Não retornado quando `state` é `disabled` ou `requesting`. |
### limit_conn
```nginx
limit_conn_zone $binary_remote_addr zone=limit_conn_zone:10m;
```
#### `/status/http/limit_conns/`, `/status/stream/limit_conns/`
Objetos para cada [limit_conn em http](#limit-conn) ou [limit_conn em stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_limit_conn.md#s-limit-conn) configurado nos contextos com os seguintes campos:
```json
{
"passed": 73,
"skipped": 0,
"rejected": 0,
"exhausted": 0
}
```
| `passed` | Número; o número total de conexões aprovadas |
|-------------|----------------------------------------------------------------------------------------------------------|
| `skipped` | Número; o número total de conexões aprovadas com chave de comprimento zero, ou chave excedendo 255 bytes |
| `rejected` | Número; o número total de conexões excedendo o limite configurado |
| `exhausted` | Número; o número total de conexões rejeitadas devido ao esgotamento do armazenamento da zona |
### limit_req
```nginx
limit_req_zone $binary_remote_addr zone=limit_req_zone:10m rate=1r/s;
```
#### `/status/http/limit_reqs/`
Objetos para cada [limit_req](#limit-req) configurado com os seguintes campos:
```json
{
"passed": 54816,
"skipped": 0,
"delayed": 65,
"rejected": 26,
"exhausted": 0
}
```
| `passed` | Número; o número total de requisições aprovadas |
|-------------|-------------------------------------------------------------------------------------------------------------|
| `skipped` | Número; o número total de requisições aprovadas com chave de comprimento zero, ou chave excedendo 255 bytes |
| `delayed` | Número; o número total de requisições atrasadas |
| `rejected` | Número; o número total de requisições rejeitadas |
| `exhausted` | Número; o número total de requisições rejeitadas devido ao esgotamento do armazenamento da zona |
### HTTP upstream
Para habilitar a coleta das seguintes métricas,
defina a diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone) no contexto [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream),
por exemplo:
```nginx
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
```
O uso de memória desta zona de memória compartilhada é informado na seção da API
[/status/slabs/](#samp-status-slabs-zone), indexado pelo nome da zona.
#### `/status/http/upstreams/`
onde é o nome de qualquer [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) especificado com a diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone)
```json
{
"peers": {
"192.168.16.4:80": {
"server": "backend.example.com",
"service": "_example._tcp",
"backup": false,
"weight": 5,
"state": "up",
"selected": {
"current": 2,
"total": 232
},
"max_conns": 5,
"responses": {
"200": 222,
"302": 12
},
"data": {
"sent": 543866,
"received": 27349934
},
"health": {
"fails": 0,
"unavailable": 0,
"downtime": 0
},
"sid": ""
}
},
"keepalive": 2
}
```
| `peers` | Objeto; contém as métricas dos peers do upstream como subobjetos cujos nomes são representações canônicas dos endereços dos peers. Membros de cada subobjeto: |
|----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `server` | String; o parâmetro da diretiva [server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) |
| `service` | String; nome do serviço como especificado na diretiva [server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), se configurado |
| `backup` | Booleano; `true` para servidores de backup |
| `weight` | Número; [peso](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) configurado |
| `state` | String; o estado atual do peer e quais requisições são enviadas para ele:
- `busy`: indica que o número de requisições para o servidor atingiu o limite definido por [max_conns](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server), e nenhuma nova requisição é enviada para ele; - `down`: desabilitado manualmente, nenhuma requisição é enviada; - `draining`: similar a `down`, mas requisições de sessões previamente vinculadas (via [sticky](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky)) ainda são enviadas; - `recovering`: recuperando após uma falha de acordo com [slow_start](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#slow-start), mais e mais requisições são enviadas ao longo do tempo; - `unavailable`: atingiu o limite [max_fails](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails), apenas requisições de teste do cliente são enviadas em intervalos definidos por [fail_timeout](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#fail-timeout); - `up`: operacional, requisições são enviadas normalmente;
Estados adicionais no Angie PRO:
- `checking`: configurado como `essential` e sendo verificado, apenas [requisições de sonda](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe) são enviadas; - `unhealthy`: não operacional, apenas [requisições de sonda](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe) são enviadas. |
| `selected` | Objeto; estatísticas de seleção de peer |
| `current` | Número; o número atual de conexões para o peer |
| `total` | Número; número total de requisições encaminhadas para o peer |
| `last` | String ou número; momento em que o peer foi selecionado pela última vez, formatado como uma [data](#api-date-format) |
| `max_conns` | Número; o número [máximo](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server) configurado de conexões ativas simultâneas para o peer, se especificado |
| `responses` | Objeto; estatísticas de respostas |
| `` | Número; um número não-zero de respostas com status (100-599) |
| `xxx` | Número; um número não-zero de respostas com outros códigos de status |
| `data` | Objeto; estatísticas de dados |
| `received` | Número; o número total de bytes recebidos do peer |
| `sent` | Número; o número total de bytes enviados para o peer |
| `health` | Objeto; estatísticas de saúde |
| `fails` | Número; o número total de tentativas malsucedidas de comunicação com o peer |
| `unavailable` | Número; quantas vezes o peer ficou `unavailable` devido ao atingimento do limite [max_fails](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails) |
| `downtime` | Número; o tempo total (em milissegundos) quando o peer estava `unavailable` para seleção |
| `downstart` | String ou número; momento em que o peer ficou `unavailable`, formatado como uma [data](#api-date-format). O campo só está presente enquanto o peer está no estado `unavailable`; caso contrário, está ausente |
| `header_time` | Número; tempo médio (em milissegundos) para receber os cabeçalhos de resposta do servidor; veja [response_time_factor](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) |
| `response_time` | Número; tempo médio (em milissegundos) para receber a resposta completa do servidor; veja [response_time_factor](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-response-time-factor) |
| `sid` | String; [id configurado](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve) do servidor no grupo upstream |
| `feedback` (PRO) | Número; o valor médio de feedback atual usado pelo método de balanceamento de carga [feedback](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-feedback), presente apenas quando esse método é usado |
| `keepalive` | Número; o número atual de conexões em cache |
| `backup_switch` | Objeto; contém o estado atual da lógica de backup ativo, presente se [backup_switch (PRO)](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-backup-switch) estiver configurado para o upstream |
| `active` | Número; o nível do grupo ativo que está sendo usado atualmente para balanceamento de carga de requisições. Se o grupo ativo for o primário, o valor é 0 |
| `timeout` | Número; tempo de espera restante em milissegundos, após o qual o balanceador irá verificar novamente por nós saudáveis em grupos com níveis mais baixos, começando pelo grupo primário, enquanto grupos com níveis mais altos não são verificados; não exibido para o grupo primário (nível 0) |
##### `health/probes` (PRO)
Se o upstream tiver sondas [upstream_probe (PRO)](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe) configuradas,
o objeto `health` também possui um subobjeto `probes`
que armazena os contadores de sonda de saúde do servidor,
enquanto `state`, além dos valores listados na tabela acima,
também pode ser `checking` e `unhealthy`:
```json
{
"192.168.16.4:80": {
"state": "unhealthy",
"...": "...",
"health": {
"...": "...",
"probes": {
"count": 10,
"fails": 10,
"last": "2026-07-17T09:56:07Z"
}
}
}
}
```
O valor `checking` de `state` não é contado como `downtime`
e significa que o servidor, que possui uma sonda configurada como `essential`,
ainda não foi verificado;
o valor `unhealthy` significa que o servidor está com mau funcionamento.
Ambos os estados também implicam que o servidor não está incluído no balanceamento de carga.
Para detalhes das sondas de saúde, veja [upstream_probe](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream_probe.md#u-upstream-probe).
Contadores em `probes`:
| `count` | Número; total de sondas para este servidor |
|-----------|--------------------------------------------------------------------------------------------|
| `fails` | Número; total de sondas falhadas |
| `last` | String ou número; momento da última sonda, formatado como uma [data](#api-date-format) |
##### `queue` (PRO)
Se uma [fila de requisições](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-queue) estiver configurada para o upstream,
o objeto upstream também contém um objeto `queue` aninhado
com contadores da fila de requisições:
```json
{
"queue": {
"queued": 20112,
"waiting": 1011,
"dropped": 6031,
"timedout": 560,
"overflows": 13
}
}
```
Os valores dos contadores são somados em todos os processos worker:
| `queued` | Número; número total de requisições que entraram na fila |
|-------------|------------------------------------------------------------------------------------------------------------|
| `waiting` | Número; número atual de requisições na fila |
| `dropped` | Número; número total de requisições removidas da fila porque o cliente fechou prematuramente a conexão |
| `timedout` | Número; número total de requisições removidas da fila devido a timeout |
| `overflows` | Número; número total de ocorrências de overflow da fila |
### Upstream de stream
Para habilitar a coleta das seguintes métricas,
defina a diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone) no contexto [upstream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream),
por exemplo:
```nginx
upstream upstream {
zone upstream 256k;
server backend.example.com service=_example._tcp resolve max_conns=5;
keepalive 4;
}
```
O uso de memória desta zona de memória compartilhada é informado na seção da API
[/status/slabs/](#samp-status-slabs-zone), indexado pelo nome da zona.
#### `/status/stream/upstreams/`
Aqui, é o nome de um [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) que está
configurado com uma diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone).
```json
{
"peers": {
"192.168.16.4:1935": {
"server": "backend.example.com",
"service": "_example._tcp",
"backup": false,
"weight": 5,
"state": "up",
"selected": {
"current": 2,
"total": 232
},
"max_conns": 5,
"data": {
"sent": 543866,
"received": 27349934
},
"health": {
"fails": 0,
"unavailable": 0,
"downtime": 0
}
}
}
}
```
| `peers` | Objeto; contém as métricas dos peers do upstream como subobjetos cujos nomes são representações canônicas dos endereços dos peers. Membros de cada subobjeto: |
|-------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `server` | String; endereço definido pela diretiva [server](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) |
| `service` | String; nome do serviço, se definido pela diretiva [server](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) |
| `backup` | Booleano; `true` para servidores de backup |
| `weight` | Número; o [peso](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) definido para o peer |
| `state` | String; o estado atual do peer e quais requisições são enviadas para ele:
- `busy`: indica que o número de requisições para o servidor atingiu o limite definido por [max_conns](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server), e nenhuma nova requisição é enviada para ele - `down`: desabilitado manualmente, nenhuma requisição é enviada - `draining`: similar a `down`, mas requisições de sessões previamente vinculadas (via [sticky](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-sticky)) ainda são enviadas - `recovering`: recuperando após uma falha de acordo com [slow_start](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-slow-start), mais e mais requisições são enviadas ao longo do tempo - `unavailable`: atingiu o limite [max_fails](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-max-fails), apenas requisições de teste do cliente são enviadas em intervalos definidos por [fail_timeout](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-fail-timeout) - `up`: operacional, requisições são enviadas normalmente
Estados adicionais no Angie PRO:
- `checking`: configurado como `essential` e sendo verificado, apenas [requisições de sonda](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) são enviadas - `unhealthy`: não operacional, apenas [requisições de sonda](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) são enviadas |
| `selected` | Objeto; estatísticas sobre a seleção deste peer para conexões |
| `current` | Número; número atual de conexões para o peer |
| `total` | Número; número total de conexões encaminhadas para o peer |
| `last` | String ou número; momento em que o peer foi selecionado pela última vez, formatado como uma [data](#api-date-format) |
| `max_conns` | Número; número [máximo](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server) de conexões ativas simultâneas para o peer, se definido |
| `data` | Objeto; estatísticas de transferência de dados |
| `received` | Número; total de bytes recebidos do peer |
| `sent` | Número; total de bytes enviados para o peer |
| `health` | Objeto; estatísticas de saúde do peer |
| `fails` | Número; total de tentativas falhadas para alcançar o peer |
| `unavailable` | Número; número total de vezes que o peer ficou `unavailable` devido a atingir o valor [max_fails](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-max-fails) |
| `downtime` | Número; tempo total (em milissegundos) que o peer esteve `unavailable` (indisponível para seleção) |
| `downstart` | String ou número; momento em que o peer ficou `unavailable` pela última vez, formatado como uma [data](#api-date-format). O campo só está presente enquanto o peer está no estado `unavailable`; caso contrário, está ausente |
| `connect_time` (PRO 1.4.0+) | Número; tempo médio (em milissegundos) para estabelecer uma conexão com o servidor; veja a diretiva [response_time_factor](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `first_byte_time` (PRO 1.4.0+) | Número; tempo médio (em milissegundos) para receber o primeiro byte da resposta do servidor; veja a diretiva [response_time_factor](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `last_byte_time` (PRO 1.4.0+) | Número; tempo médio (em milissegundos) para receber a resposta completa do servidor; veja a diretiva [response_time_factor](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-response-time-factor) |
| `feedback` (PRO) | Número; o valor médio de feedback atual usado pelo método de balanceamento de carga [feedback](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-feedback), presente apenas quando esse método é usado |
| `backup_switch` (PRO 1.10.0+) | Objeto; contém o estado atual da lógica de backup ativo, presente se [backup_switch (PRO)](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-backup-switch) estiver configurado para o upstream |
| `active` | Número; nível do grupo ativo atualmente usado para balanceamento de carga. Se o grupo ativo for o grupo primário, o valor é 0 |
| `timeout` | Número; tempo de espera restante em milissegundos após o qual o balanceador de carga irá verificar novamente por nós saudáveis em grupos com níveis mais baixos, começando pelo grupo primário, enquanto grupos com níveis mais altos não são verificados; não exibido para o grupo primário (nível 0) |
No Angie PRO, se o upstream tiver sondas [upstream_probe (PRO)](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe) configuradas,
o objeto `health` também tem um subobjeto `probes`
que armazena os contadores de sonda de saúde do servidor,
enquanto `state`, além dos valores da tabela acima,
também pode ser `checking` e `unhealthy`:
```json
{
"192.168.16.4:80": {
"state": "unhealthy",
"...": "...",
"health": {
"...": "...",
"probes": {
"count": 2,
"fails": 2,
"last": "2026-07-17T11:03:54Z"
}
}
}
}
```
O valor `checking` de `state` significa que o servidor,
que tem uma sonda configurada com o parâmetro `essential`,
ainda não foi verificado;
o valor `unhealthy` significa que o servidor não está operacional.
Ambos os estados também significam que o servidor não está incluído no balanceamento de carga.
Para detalhes das sondas de saúde, veja [upstream_probe](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream_probe.md#s-u-upstream-probe).
Contadores em `probes`:
| `count` | Número; número total de sondas para este servidor |
|-----------|--------------------------------------------------------------------------------------------|
| `fails` | Número; número de sondas falhadas |
| `last` | String ou número; momento da última sonda, formatado como uma [data](#api-date-format) |
## Certificados
### `/certificates/`
Um objeto de nível superior da API, separado da árvore de estatísticas
[/status/](#metrics), que informa os certificados TLS que o Angie carregou.
Um certificado não é listado sob `static` se o nome de seu arquivo de
certificado ou de chave contiver uma variável, incluindo uma fornecida por um
cliente ACME através da variável [$acme_cert_](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#v-acme-cert-name).
Um certificado compartilhado por vários servidores é listado uma única vez.
O exemplo a seguir carrega um certificado estático e obtém outro certificado
com um cliente ACME. O cliente ACME requer um [resolver](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver) configurado para
resolver o nome de host do diretório:
```nginx
http {
resolver 127.0.0.53;
acme_client example https://acme.example.com/directory;
server {
listen 443 ssl;
server_name www.example.com;
ssl_certificate example.com.crt;
ssl_certificate_key example.com.key;
location /certificates/ {
api /certificates/;
}
}
server {
listen 443 ssl;
server_name acme.example.com;
acme example;
ssl_certificate $acme_cert_example;
ssl_certificate_key $acme_cert_key_example;
}
}
```
Em resposta à requisição
`curl https://www.example.com/certificates/`, o Angie retorna:
```json
{
"static": {
"example.com.crt": {
"key": "RSA (2048 bits)",
"chain": [
{
"subject": {
"common_name": "example.com",
"alt_names": [
"example.com",
"www.example.com"
],
"organization": "Example, Inc."
},
"issuer": {
"common_name": "Example Root CA",
"country": "US",
"organization": "Example, Inc."
},
"validity": {
"since": "Sep 18 19:46:19 2022 GMT",
"until": "Jun 15 19:46:19 2025 GMT"
}
}
]
}
},
"acme_clients": {
"example": {
"key": "EC (prime256v1)",
"chain": [
{
"subject": {
"common_name": "acme.example.com"
},
"issuer": {
"common_name": "Example ACME CA"
},
"validity": {
"since": "Sep 18 19:46:19 2022 GMT",
"until": "Dec 17 19:46:19 2022 GMT"
}
}
]
}
}
}
```
| `static` | Objeto; certificados de servidor definidos com [ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/http/http_ssl.md#ssl-certificate) em HTTP, [ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_ssl.md#s-ssl-certificate) em Stream, ou [ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/mail/mail_ssl.md#m-ssl-certificate) em Mail, cada um indexado pelo nome do arquivo de certificado. Em compilações com `--with-ntls`, também inclui certificados definidos com [proxy_ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ssl-certificate) em HTTP ou [proxy_ssl_certificate](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-ssl-certificate) em Stream para autenticação em servidores proxy |
|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `acme_clients` | Objeto; disponível quando o Angie é compilado com o [módulo HTTP ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#http-acme), que também é exigido pelo [módulo Stream ACME](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_acme.md#stream-acme). Contém certificados obtidos por [clientes ACME](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client) para servidores HTTP e Stream. Cada entrada é indexada pelo nome de [acme_client](https://pt.angie.software//angie/docs/configuration/modules/http/http_acme.md#acme-client). Apenas os clientes que já obtiveram um certificado são listados |
Cada entrada de `static` e `acme_clients` descreve um único pacote
de certificados:
| `key` | String; tipo e tamanho da chave privada (ou curva), por exemplo `RSA (2048 bits)`, `EC (prime256v1)`, ou `DH (2048 bits)` |
|---------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `chain` | Array; os certificados do pacote, começando pelo certificado folha (servidor) seguido pelos certificados intermediários, em direção à raiz. Cada elemento é um objeto que descreve um certificado: |
| `subject` | Objeto; o nome distinto (DN) do titular |
| `common_name` | String; Common Name (`CN`) |
| `alt_names` | Array de strings; os nomes DNS e endereços IP da extensão Subject Alternative Name |
| `country` | String; Country (`C`) |
| `state_or_province` | String; State or Province Name (`ST`) |
| `organization` | String; Organization (`O`) |
| `issuer` | Objeto; o nome distinto (DN) do emissor, com os mesmos campos que `subject` |
| `validity` | Objeto; o período de validade do certificado |
| `since` | String; início do período de validade (`notBefore`) |
| `until` | String; fim do período de validade (`notAfter`) |
Os campos de `subject` e `issuer` aparecem apenas quando presentes
no certificado.
## API de Configuração Dinâmica (PRO)
A API inclui uma seção `/config` que permite atualizações dinâmicas
na configuração do Angie em formato JSON
com requisições HTTP `PUT`, `PATCH` e `DELETE`.
Todas as atualizações são atômicas: as novas configurações são aplicadas como um todo,
ou nenhuma é aplicada.
Em caso de erro, o Angie reporta o motivo.
### Subseções de `/config`
Atualmente, a configuração de servidores individuais dentro de upstreams está disponível
na seção `/config` para os módulos [HTTP](#api-config-http-upstreams-servers) e [stream](#api-config-stream-upstreams-servers); o número de configurações
elegíveis para configuração dinâmica está aumentando constantemente.
#### `/config/http/upstreams//servers/`
Permite configurar peers individuais de upstream,
incluindo excluir peers existentes ou adicionar novos.
Parâmetros do caminho URI:
| `` | Nome do upstream; para ser configurável via `/config`, deve ter uma diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone) configurada, definindo uma zona de memória compartilhada. |
|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `` | O nome do peer dentro do upstream, definido como `@`, onde:
- `@` é um nome de serviço opcional, usado para resolução de registros SRV. - `` é o nome de domínio do serviço (se `resolve` estiver presente) ou seu IP; uma porta opcional pode ser definida aqui. |
Por exemplo, a seguinte configuração:
```nginx
upstream backend {
server backend.example.com service=_http._tcp resolve;
server 127.0.0.1;
zone backend 1m;
}
```
Permite os seguintes nomes de peer:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/_http._tcp@backend.example.com/
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/127.0.0.1:80/
```
Esta subseção da API permite definir os parâmetros `weight`, `max_conns`,
`max_fails`, `fail_timeout`, `slow_start`, `backup`, `down` e
`sid`, conforme descrito em [server](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-server).
#### NOTE
Não há um parâmetro `drain` separado aqui;
para habilitar `drain`,
defina `down` para o valor string `drain`:
```console
$ curl -X PUT -d \"drain\" \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/down
```
Exemplo:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 0,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": true,
"down": false,
"sid": ""
}
```
Os parâmetros realmente disponíveis são limitados aos suportados pelo
método de balanceamento de carga atual do [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream).
Então, se o upstream estiver configurado com o método `random`:
```nginx
upstream backend {
zone backend 256k;
server backend.example.com resolve max_conns=5;
random;
}
```
Você não conseguirá adicionar um novo peer que defina `backup`:
```console
$ curl -X PUT -d '{ "backup": true }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend1.example.com
```
```json
{
"error": "FormatError",
"description": "The \"backup\" field is unknown."
}
```
#### `/config/stream/upstreams//servers/`
Permite configurar peers individuais de upstream,
incluindo excluir peers existentes ou adicionar novos.
Parâmetros do caminho URI:
| `` | Nome do bloco `upstream`; para ser configurável via `/config`, deve ter uma diretiva [zone](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone) configurada, definindo uma zona de memória compartilhada. |
|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `` | O nome do peer dentro do upstream, definido como `@`, onde:
- `@` é um nome de serviço opcional, usado para resolução de registros SRV. - `` é o nome de domínio do serviço (se `resolve` estiver presente) ou seu IP; uma porta opcional pode ser definida aqui. |
Por exemplo, a seguinte configuração:
```nginx
upstream backend {
server backend.example.com:8080 service=_example._tcp resolve;
server 127.0.0.1:12345;
zone backend 1m;
}
```
Permite os seguintes nomes de peer:
```console
$ curl http://127.0.0.1/config/stream/upstreams/backend/servers/_example._tcp@backend.example.com:8080/
$ curl http://127.0.0.1/config/stream/upstreams/backend/servers/127.0.0.1:12345/
```
Esta subseção da API permite definir os parâmetros `weight`,
`max_conns`, `max_fails`, `fail_timeout`, `slow_start`, `backup` e
`down`, conforme descrito em [server](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-server).
#### NOTE
Não há um parâmetro `drain` separado aqui;
para habilitar o modo `drain`,
defina `down` para o valor string `drain`:
```console
$ curl -X PUT -d \"drain\" \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend.example.com/down
```
Exemplo:
```console
curl http://127.0.0.1/config/stream/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 0,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": true,
"down": false,
}
```
Os parâmetros realmente disponíveis são limitados aos suportados pelo
método de balanceamento de carga atual do [upstream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream).
Então, se o upstream estiver configurado com o método `random`:
```nginx
upstream backend {
zone backend 256k;
server backend.example.com resolve max_conns=5;
random;
}
```
Você não conseguirá adicionar um novo peer que defina `backup`:
```console
$ curl -X PUT -d '{ "backup": true }' \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend1.example.com
```
```json
{
"error": "FormatError",
"description": "The \"backup\" field is unknown."
}
```
Ao excluir peers, você pode definir o
argumento `connection_drop=` (PRO) para sobrescrever as
configurações [proxy_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_proxy.md#s-proxy-connection-drop):
```console
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend1.example.com?connection_drop=off
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend2.example.com?connection_drop=on
$ curl -X DELETE \
http://127.0.0.1/config/stream/upstreams/backend/servers/backend3.example.com?connection_drop=1000
```
### Métodos HTTP
Vamos considerar a semântica de cada método HTTP aplicável a esta seção
usando a seguinte configuração upstream como exemplo:
```nginx
http {
# ...
upstream backend {
zone upstream 256k;
server backend.example.com resolve max_conns=5;
# ...
}
server {
# ...
location /config/ {
api /config/;
allow 127.0.0.1;
deny all;
}
}
}
```
#### GET
O método HTTP `GET` consulta uma entidade em qualquer caminho existente dentro de
`/config`, assim como faz para outras seções da API.
Por exemplo, o
ramo de servidor upstream `/config/http/upstreams/backend/servers/`
habilita estas consultas:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_conns
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
$ curl http://127.0.0.1/config/http/upstreams/backend/servers
$ # ...
$ curl http://127.0.0.1/config
```
Você pode obter valores de parâmetros padrão com o argumento
`defaults=on`; consulte [Argumentos da query string](#api-query-arguments).
#### PUT
O método HTTP `PUT` cria uma nova entidade JSON no caminho especificado
ou substitui *inteiramente* uma existente.
Por exemplo, para adicionar o parâmetro `max_fails`, não especificado anteriormente,
ao servidor `backend.example.com` dentro do upstream `backend`:
```console
$ curl -X PUT -d '2' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_fails
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com/max_fails\" was updated with replacing."
}
```
Verifique as alterações:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 5,
"max_fails": 2
}
```
#### DELETE
O método HTTP `DELETE` exclui configurações *previamente definidas* no caminho especificado;
ao fazer isso, restaura os valores padrão se houver algum.
Por exemplo, para excluir o parâmetro `max_fails` previamente modificado
do servidor `backend.example.com` dentro do upstream `backend`:
```console
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com/max_fails
```
```console
{
"success": "Reset",
"description": "Configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com/max_fails\" was reset to default."
}
```
Verifique as alterações usando o argumento `defaults=on`:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com?defaults=on
```
```json
{
"weight": 1,
"max_conns": 5,
"max_fails": 1,
"fail_timeout": 10,
"slow_start": 0,
"backup": false,
"down": false,
"sid": ""
}
```
O parâmetro `max_fails` retornou ao seu valor padrão.
Ao excluir servidores, você pode definir o argumento `connection_drop=`
(PRO) para sobrescrever as configurações [proxy_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-connection-drop), [grpc_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-connection-drop),
[fastcgi_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-connection-drop), [scgi_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-connection-drop) e
[uwsgi_connection_drop](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-connection-drop):
```console
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend1.example.com?connection_drop=off
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend2.example.com?connection_drop=on
$ curl -X DELETE \
http://127.0.0.1/config/http/upstreams/backend/servers/backend3.example.com?connection_drop=1000
```
#### PATCH
O método HTTP `PATCH` cria uma nova entidade no caminho especificado
ou substitui parcialmente ou complementa uma existente
([RFC 7386](https://datatracker.ietf.org/doc/html/rfc7396))
fornecendo uma definição JSON em seu payload.
O método opera da seguinte forma: se as entidades da nova definição
existem na configuração, elas são sobrescritas; caso contrário, são adicionadas.
Por exemplo, para alterar o parâmetro `down` do
servidor `backend.example.com` dentro do upstream `backend`,
deixando o resto intacto:
```console
$ curl -X PATCH -d '{ "down": true }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com\" was updated with merging."
}
```
Verifique as alterações:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 5,
"down": true
}
```
Observe que o objeto JSON fornecido com a requisição `PATCH` *foi mesclado* com o
existente em vez de substituí-lo inteiramente, como seria o caso com `PUT`.
Os valores `null` são um caso especial; eles são usados para excluir
itens específicos de configuração durante tal mesclagem.
#### NOTE
Esta exclusão é idêntica ao `DELETE`;
em particular, ela restaura os valores padrão.
Por exemplo, para excluir o parâmetro `down` adicionado anteriormente
e simultaneamente atualizar `max_conns`:
```console
$ curl -X PATCH -d '{ "down": null, "max_conns": 6 }' \
http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"success": "Updated",
"description": "Existing configuration API entity \"/config/http/upstreams/backend/servers/backend.example.com\" was updated with merging."
}
```
Verifique as alterações:
```console
$ curl http://127.0.0.1/config/http/upstreams/backend/servers/backend.example.com
```
```json
{
"max_conns": 6
}
```
O parâmetro `down`, para o qual um valor `null` foi fornecido, foi excluído;
o valor de `max_conns` foi atualizado.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_auth_basic.md
# Auth Basic
Permite limitar o acesso a recursos validando o nome de usuário e senha usando o protocolo "HTTP Basic Authentication".
O acesso também pode ser limitado por [endereço](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) ou pelo
[resultado de subrequest](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_request.md#http-auth-request). A limitação simultânea de
acesso por endereço e por senha é controlada pela diretiva [satisfy](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Exemplo de Configuração
```nginx
location / {
auth_basic "site fechado";
auth_basic_user_file conf/htpasswd;
}
```
## Diretivas
### auth_basic
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_basic` string | `off`; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | `auth_basic off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Habilita a validação de nome de usuário e senha usando o protocolo "HTTP Basic Authentication". O parâmetro especificado é usado como realm. O valor do parâmetro pode conter [variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables).
| `off` | cancela o efeito da diretiva auth_basic herdada do nível de configuração anterior |
|---------|-------------------------------------------------------------------------------------|
### auth_basic_user_file
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_basic_user_file` arquivo; |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, limit_except |
Especifica um arquivo que mantém nomes de usuário e senhas. O formato é o seguinte:
```none
# comentário
nome1:senha1
nome2:senha2:comentário
nome3:senha3
```
O nome do arquivo pode conter variáveis.
Os seguintes tipos de senha são suportados:
* criptografadas com a função crypt(); podem ser geradas usando o utilitário `htpasswd` da distribuição do Apache HTTP Server ou o comando "openssl passwd";
* com hash da variante Apache do algoritmo de senha baseado em MD5 (apr1); podem ser geradas com as mesmas ferramentas;
* especificadas pela sintaxe "{scheme}data" conforme descrito na [RFC 2307](https://datatracker.ietf.org/doc/html/rfc2307#section-5.3); esquemas atualmente implementados incluem PLAIN (um exemplo, não deve ser usado), SHA (hash SHA-1 simples, não deve ser usado) e SSHA (hash SHA-1 com salt, usado por alguns pacotes de software, notavelmente OpenLDAP e Dovecot).
#### WARNING
O suporte para o esquema SHA foi adicionado apenas para auxiliar na migração de outros servidores web. Não deve ser usado para novas senhas, pois o hash SHA-1 sem salt que ele emprega é vulnerável a ataques de [rainbow table](http://en.wikipedia.org/wiki/Rainbow_attack).
# https://pt.angie.software/angie/docs/configuration/modules/http/http_auth_request.md
# Auth Request
Implementa autorização de cliente baseada no resultado de uma subrequisição. Se a subrequisição retornar um código de resposta 2xx, o acesso é permitido. Se retornar 401 ou 403, o acesso é negado com o código de erro correspondente. Qualquer outro código de resposta retornado pela subrequisição é considerado um erro.
Para o erro 401, o cliente também recebe o cabeçalho `WWW-Authenticate` da resposta da subrequisição.
Ao [compilar a partir do código-fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo não é compilado por padrão;
deve ser habilitado com a
`‑‑with‑http_auth_request_module`
[opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure).
Em pacotes e imagens dos [nossos repositórios](https://pt.angie.software//angie/docs/installation/index.md#install-packages),
o módulo está incluído na compilação.
O módulo pode ser combinado com outros módulos de acesso, como
[Access](https://pt.angie.software//angie/docs/configuration/modules/http/http_access.md#http-access) e [Auth Basic](https://pt.angie.software//angie/docs/configuration/modules/http/http_auth_basic.md#http-auth-basic), através da diretiva [satisfy](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#satisfy).
## Exemplo de Configuração
```nginx
location /private/ {
auth_request /auth;
# ...
}
location = /auth {
proxy_pass ...;
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_set_header X-Original-URI $request_uri;
}
```
## Diretivas
### auth_request
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_request` `uri` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | `auth_request off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita autorização baseada no resultado de uma subrequisição e define o URI para o qual a subrequisição será enviada.
### auth_request_set
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `auth_request_set` $variable value; |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define a variável de requisição para o valor fornecido após a requisição de autorização ser concluída. O valor pode conter [variáveis](https://pt.angie.software//angie/docs/configuration/configfile.md#string-variables) da requisição de autorização, como `$upstream_http_*`.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_autoindex.md
# AutoIndex
Atende requisições terminadas com uma barra (`/`) e produz uma listagem de diretório. Geralmente, uma requisição é passada para o módulo `AutoIndex` quando o módulo [Index](https://pt.angie.software//angie/docs/configuration/modules/http/http_index.md#http-index) não consegue encontrar um arquivo de índice.
## Exemplo de Configuração
```nginx
location / {
autoindex on;
}
```
## Diretivas
### autoindex
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex` `on` | `off`; |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão | `autoindex off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita ou desabilita a saída de listagem de diretório.
### autoindex_exact_size
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_exact_size` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `autoindex_exact_size on;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Para o [formato](#autoindex-format) HTML, especifica se os tamanhos exatos dos arquivos devem ser exibidos na listagem do diretório, ou se devem ser arredondados para kilobytes, megabytes e gigabytes.
### autoindex_format
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_format` `html` | `xml` | `json` | `jsonp`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------------------|
| Padrão | `autoindex_format html;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define o formato de uma listagem de diretório.
Quando o formato JSONP é usado, o nome de uma função de callback é definido com o argumento de requisição `callback`. Se o argumento estiver ausente ou tiver um valor vazio, então o formato JSON é usado.
A saída XML pode ser transformada usando o módulo [XSLT](https://pt.angie.software//angie/docs/configuration/modules/http/http_xslt.md#http-xslt).
### Formatos de Saída
Os campos de objeto nas respostas contêm os seguintes dados:
| Campo | Descrição |
|---------|----------------------------------------------------------------------------------------------------------|
| `name` | Nome do arquivo ou diretório |
| `type` | Tipo do objeto: `file` ou `directory` |
| `size` | Tamanho do objeto de acordo com [autoindex_exact_size](#autoindex-exact-size); para diretórios — `0` |
| `mtime` | Horário da última modificação no formato Unix time |
HTML
```html
Index of /files/
```
XML
```xml
example.txtfile12342025-06-12T14:21:00Zimage.pngfile43212025-06-12T14:21:00Z
```
JSON
```json
[
{
"name": "example.txt",
"type": "file",
"size": 1234,
"mtime": "2025-06-12T14:21:00Z"
},
{
"name": "image.png",
"type": "file",
"size": 4321,
"mtime": "2025-06-12T14:21:00Z"
}
]
```
JSONP
```javascript
callback([
{
"name": "example.txt",
"type": "file",
"size": 1234,
"mtime": "2025-06-12T14:21:00Z"
},
{
"name": "image.png",
"type": "file",
"size": 4321,
"mtime": "2025-06-12T14:21:00Z"
}
]);
```
### autoindex_localtime
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `autoindex_localtime` `on` | `off`; |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão | `autoindex_localtime off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Para o [formato](#autoindex-format) HTML, especifica se os horários na listagem do diretório devem ser exibidos no fuso horário local ou UTC.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_browser.md
# Browser
O módulo cria variáveis cujos valores dependem do valor do campo de cabeçalho de requisição `User-Agent`.
## Variáveis
### `$ancient_browser`
igual ao valor definido pela diretiva [ancient_browser_value](#ancient-browser-value), se um navegador foi identificado como antigo;
### `$modern_browser`
igual ao valor definido pela diretiva [modern_browser_value](#modern-browser-value), se um navegador foi identificado como moderno;
### `$msie`
igual a "1" se um navegador foi identificado como MSIE de qualquer versão.
## Exemplo de Configuração
### Escolhendo um arquivo de índice:
```nginx
modern_browser_value "modern.";
modern_browser msie 5.5;
modern_browser gecko 1.0.0;
modern_browser opera 9.0;
modern_browser safari 413;
modern_browser konqueror 3.0;
index index.${modern_browser}html index.html;
```
### Redirecionamento para navegadores antigos:
```nginx
modern_browser msie 5.0;
modern_browser gecko 0.9.1;
modern_browser opera 8.0;
modern_browser safari 413;
modern_browser konqueror 3.0;
modern_browser unlisted;
ancient_browser Links Lynx netscape4;
if ($ancient_browser) {
rewrite ^ /ancient.html;
}
```
## Diretivas
### ancient_browser
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `ancient_browser` string ...; |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Se qualquer uma das substrings especificadas for encontrada no campo de cabeçalho de requisição `User-Agent`, o navegador será considerado antigo. A string especial "netscape4" corresponde à expressão regular "^Mozilla/[1-4]".
### ancient_browser_value
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `ancient_browser_value` string; |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão | `ancient_browser_value 1;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um valor para a variável [$ancient_browser](#v-ancient-browser).
### modern_browser
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `modern_browser` browser version;
`modern_browser` `unlisted`; |
|-------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Especifica uma versão a partir da qual um navegador é considerado moderno. Um
navegador pode ser qualquer um dos seguintes: `msie`, `gecko` (navegadores
baseados no Mozilla), `opera`, `safari`, ou `konqueror`.
As versões podem ser especificadas nos seguintes formatos: X, X.X, X.X.X, ou X.X.X.X. Os valores máximos para cada um dos formatos são 4000, 4000.99, 4000.99.99, e 4000.99.99.99, respectivamente.
O valor especial `unlisted` especifica para considerar um navegador como moderno se ele não foi listado pelas diretivas `modern_browser` e [ancient_browser](#id1). Caso contrário, tal navegador é considerado antigo. Se uma requisição não fornecer o campo `User-Agent` no cabeçalho, o navegador é tratado como não listado.
### modern_browser_value
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `modern_browser_value` string; |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão | `modern_browser_value 1;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define um valor para a variável [$modern_browser](#v-modern-browser).
# https://pt.angie.software/angie/docs/configuration/modules/http/http_charset.md
# Charset
O módulo adiciona o charset especificado ao campo de cabeçalho de resposta `Content-Type`. Além disso, o módulo pode converter dados de um charset para outro, com algumas limitações:
* a conversão é realizada em uma direção — do servidor para o cliente,
* apenas charsets de byte único podem ser convertidos
* ou charsets de byte único para/de UTF-8.
## Exemplo de Configuração
```nginx
include conf/koi-win;
charset windows-1251;
source_charset koi8-r;
```
## Diretivas
### charset
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset` charset | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `charset off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Adiciona o charset especificado ao campo de cabeçalho de resposta `Content-Type`. Se este charset for diferente do charset especificado na diretiva [source_charset](#source-charset), uma conversão é realizada.
O parâmetro `off` cancela a adição do charset ao campo de cabeçalho de resposta `Content-Type`.
Um charset pode ser definido com uma variável:
```nginx
charset $charset;
```
Neste caso, todos os valores possíveis de uma variável precisam estar presentes na
configuração pelo menos uma vez na forma das diretivas [charset_map](#charset-map),
[charset](#id1), ou [source_charset](#source-charset). Para os charsets `utf-8`,
`windows-1251`, e `koi8-r`, é suficiente incluir
os arquivos `conf/koi-win`, `conf/koi-utf`, e `conf/win-utf`
na configuração. Para outros charsets, simplesmente criar uma tabela de conversão
fictícia funciona, por exemplo:
```nginx
charset_map iso-8859-5 _ { }
```
Além disso, um charset pode ser definido no campo de cabeçalho de resposta `X-Accel-Charset`. Esta capacidade pode ser desabilitada usando as diretivas [proxy_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#proxy-ignore-headers), [fastcgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_fastcgi.md#fastcgi-ignore-headers), [uwsgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_uwsgi.md#uwsgi-ignore-headers), [scgi_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_scgi.md#scgi-ignore-headers), e [grpc_ignore_headers](https://pt.angie.software//angie/docs/configuration/modules/http/http_grpc.md#grpc-ignore-headers).
### charset_map
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset_map` charset1 charset2 { ... } |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http |
Descreve a tabela de conversão de um charset para outro. Uma tabela de conversão reversa é construída usando os mesmos dados. Códigos de caracteres são dados em hexadecimal. Caracteres ausentes no intervalo 80-FF são substituídos por "?". Ao converter de UTF-8, caracteres ausentes em um charset de byte único são substituídos por "&#XXXX;".
Exemplo:
```nginx
charset_map koi8-r windows-1251 {
C0 FE ; # small yu
C1 E0 ; # small a
C2 E1 ; # small b
C3 F6 ; # small ts
}
```
Ao descrever uma tabela de conversão para UTF-8, códigos para o charset UTF-8 devem ser dados na segunda coluna, por exemplo:
```nginx
charset_map koi8-r utf-8 {
C0 D18E ; # small yu
C1 D0B0 ; # small a
C2 D0B1 ; # small b
C3 D186 ; # small ts
}
```
Tabelas de conversão completas de `koi8-r` para `windows-1251`, e de
`koi8-r` e `windows-1251` para `utf-8` são fornecidas nos
arquivos de distribuição `conf/koi-win`, `conf/koi-utf`, e
`conf/win-utf`.
### charset_types
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `charset_types` mime-type ...; |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
| Padrão | `charset_types text/html text/xml text/plain text/vnd.wap.wml application/javascript application/rss+xml;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Habilita o processamento do módulo em respostas com os tipos MIME especificados além de `text/html`. O valor especial `*` corresponde a qualquer tipo MIME.
### override_charset
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `override_charset` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `override_charset off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Determina se uma conversão deve ser realizada para respostas recebidas de um servidor proxy ou FastCGI/uwsgi/SCGI/gRPC quando as respostas já carregam um charset no campo de cabeçalho de resposta `Content-Type`. Se a conversão estiver habilitada, um charset especificado na resposta recebida é usado como charset de origem.
#### NOTE
Se uma resposta é recebida em uma subrequisição, então a conversão do charset da resposta para o charset da requisição principal é sempre realizada, independentemente da configuração da diretiva override_charset.
### source_charset
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `source_charset` charset; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | — |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location, if in location |
Define o charset de origem de uma resposta. Se este charset for diferente do charset especificado na diretiva [charset](#id1), uma conversão é realizada.
# https://pt.angie.software/angie/docs/configuration/modules/http/http_dav.md
# DAV
O módulo é destinado à automação do gerenciamento de arquivos via protocolo WebDAV. O módulo processa métodos HTTP e WebDAV PUT, DELETE, MKCOL, COPY e MOVE.
Ao [compilar a partir do código fonte](https://pt.angie.software//angie/docs/installation/sourcebuild.md#sourcebuild),
este módulo não é compilado por padrão;
deve ser habilitado com a
`‑‑with‑http_dav_module`
[opção de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#configure).
Em pacotes e imagens dos [nossos repositórios](https://pt.angie.software//angie/docs/installation/index.md#install-packages),
o módulo está incluído na compilação.
#### NOTE
Clientes WebDAV que requerem métodos WebDAV adicionais para operar não funcionarão com este módulo.
## Exemplo de Configuração
```nginx
location / {
root /data/www;
client_body_temp_path /data/client_temp;
dav_methods PUT DELETE MKCOL COPY MOVE;
create_full_put_path on;
dav_access group:rw all:r;
limit_except GET {
allow 192.168.1.0/32;
deny all;
}
}
```
## Diretivas
### create_full_put_path
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `create_full_put_path` `on` | `off`; |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão | `create_full_put_path off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
A especificação WebDAV permite apenas criar arquivos em diretórios já existentes. Esta diretiva permite criar todos os diretórios intermediários necessários.
### dav_access
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `dav_access` usuários:permissões ...; |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão | `dav_access user:rw;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Define permissões de acesso para arquivos e diretórios recém-criados, por exemplo:
```nginx
dav_access user:rw group:rw all:r;
```
Se quaisquer permissões de acesso de grupo ou todos forem especificadas, então as permissões de usuário podem ser omitidas:
```nginx
dav_access group:rw all:r;
```
### dav_methods
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `dav_methods` `off` | método ...; |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão | `dav_methods off;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite os métodos HTTP e WebDAV especificados. O parâmetro `off` nega todos os métodos processados por este módulo. Os seguintes métodos são suportados: PUT, DELETE, MKCOL, COPY e MOVE.
Um arquivo enviado com o método PUT é primeiro escrito em um arquivo temporário, e então o arquivo é renomeado. A partir da versão 0.8.9, arquivos temporários e o armazenamento persistente podem ser colocados em sistemas de arquivos diferentes. No entanto, esteja ciente de que neste caso um arquivo é copiado entre dois sistemas de arquivos em vez da operação barata de renomeação. É assim recomendado que para qualquer `location` dado tanto os arquivos salvos quanto um diretório contendo arquivos temporários, definido pela diretiva [client_body_temp_path](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#client-body-temp-path), sejam colocados no mesmo sistema de arquivos.
Ao criar um arquivo com o método PUT, é possível especificar a data de modificação passando-a no campo de cabeçalho `Date`.
### min_delete_depth
| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `min_delete_depth` número; |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão | `min_delete_depth 0;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | http, server, location |
Permite que o método DELETE remova arquivos desde que o número de elementos em um caminho de requisição não seja menor que o número especificado. Por exemplo, a diretiva
```nginx
min_delete_depth 4;
```
permite remover arquivos em requisições
```console
/users/00/00/name
/users/00/00/name/pic.jpg
/users/00/00/page.html
```
e nega a remoção de
```console
/users/00/00
```
# https://pt.angie.software/angie/docs/configuration/modules/http/http_docker.md
# Docker
#### Versionadded
Adicionado na versão 1.10.0.
O módulo fornece configuração dinâmica de grupos de servidores proxy
em contextos [HTTP](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-upstream) e [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-upstream)
baseada em labels de contêineres Docker.
Para que a funcionalidade funcione, uma zona de memória compartilhada deve ser configurada
no grupo (veja a descrição de `zone` para [http](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-zone) e [stream](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_upstream.md#s-u-zone)).
#### NOTE
O módulo suporta trabalhar tanto com Docker quanto com suas alternativas,
como Podman, que implementam uma API compatível.
A versão recomendada do Podman é 4.9.3 ou superior.
O módulo conecta-se ao daemon Docker via API,
o método de interação com o qual é especificado pela diretiva [docker_endpoint](#docker-endpoint).
Após obter uma lista de contêineres em execução,
o Angie os analisa para verificar a presença de [labels](#docker-labels) adequados.
Se uma descrição de contêiner contém um label com uma porta,
então o endereço e porta de tal contêiner,
bem como parâmetros de outros labels deste contêiner,
são automaticamente adicionados ao bloco `upstream` correspondente
na configuração do Angie.
#### NOTE
O mesmo contêiner pode ser adicionado a múltiplos grupos `upstream`.
Para isso, basta especificar múltiplos conjuntos de labels
com diferentes nomes de grupo e portas.
Isso é especialmente útil
se o contêiner executa vários serviços diferentes em portas diferentes —
cada serviço pode ser associado com seu próprio grupo.
O módulo então se inscreve em eventos do ciclo de vida dos contêineres
e começa a atualizar a configuração do servidor proxy sem recarregar o Angie:
- ao iniciar um contêiner com labels adequados,
seu endereço IP interno é adicionado ao grupo especificado;
- ao parar ou remover um contêiner,
ele é automaticamente removido do grupo;
- ao pausar um contêiner com o comando **docker pause**,
o servidor é marcado como `down`,
e com **docker unpause** — como `up`.
## Exemplo de Configuração
As diretivas do módulo estão sempre localizadas no contexto `http`,
mas grupos de servidores proxy podem ser definidos
tanto no contexto `http` quanto no contexto `stream`.
Exemplo de configuração para `http`:
```nginx
http {
# Exemplos de opções de conexão:
# docker_endpoint http://127.0.0.1:2375;
# docker_endpoint https://127.0.0.1:2376;
docker_endpoint unix:/var/run/docker.sock;
# tamanho máximo do buffer de resposta Docker (opcional)
# docker_max_object_size 128k;
upstream u {
zone z 1m; # zona de memória compartilhada é obrigatória
}
server {
listen 80;
server_name example.com;
location / {
proxy_pass http://u;
}
}
}
```
Similarmente no contexto stream:
```nginx
http {
# Exemplos de opções de conexão:
# docker_endpoint http://127.0.0.1:2375;
# docker_endpoint https://127.0.0.1:2376;
docker_endpoint unix:/var/run/docker.sock;
# tamanho máximo do buffer de resposta Docker (opcional)
# docker_max_object_size 128k;
}
stream {
upstream u {
zone z 1m;
}
server {
listen 12345;
proxy_pass u;
}
}
```
Ao receber um evento para um contêiner,
o Angie procura por labels da forma
`angie.http.upstreams..port=` (para contexto HTTP)
ou `angie.stream.upstreams..port=` (para contexto stream).
Quando um label está presente, o endereço do contêiner na rede Docker especificada
(ou a primeira disponível se o label `angie.network` não for especificado)
é adicionado ao grupo de servidores proxy correspondente.
Se um contêiner para ou é removido, o servidor é removido do grupo;
se um contêiner é pausado, o servidor é marcado como `down`.
Fragmento de um arquivo `docker-compose.yml` com labels que o Angie reconhece:
```yaml
services:
myapp:
image: myapp:latest
labels:
- "angie.http.upstreams.u.port=8080"
- "angie.network=my_bridge"
- "angie.http.upstreams.u.weight=2"
- "angie.http.upstreams.u.max_conns=50"
- "angie.http.upstreams.u.max_fails=3"
- "angie.http.upstreams.u.fail_timeout=10s"
- "angie.http.upstreams.u.backup=true"
```
## Labels
Labels especificam parâmetros do servidor no grupo de servidores proxy
similar aos argumentos da diretiva `server`:
| Label | Propósito |
|---------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------|
| `angie.(http|stream).upstreams..port=` *(obrigatório)* | Porta do contêiner à qual o Angie se conectará; o próprio contêiner é adicionado ao grupo nomeado ``. |
| `angie.network=` | Nome da rede Docker da qual obter o endereço IP do contêiner. |
| `angie.(http|stream).upstreams..weight=` | Valor do parâmetro `weight`. |
| `angie.(http|stream).upstreams..max_conns=` | Número máximo de conexões simultâneas (`max_conns`). |
| `angie.(http|stream).upstreams..max_fails=` | Limite para tentativas falhadas (`max_fails`). |
| `angie.(http|stream).upstreams..fail_timeout=` | Intervalo para contar tentativas falhadas (`fail_timeout`). |
| `angie.(http|stream).upstreams..backup=true|false` | Marca o servidor como `backup`. |
| `angie.(http|stream).upstreams..sid=` | Define um identificador de servidor personalizado (`sid`) para o servidor proxy. |
| `angie.(http|stream).upstreams..slow_start=
