# 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, 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 | [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/installation/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; } } ``` ### 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#id4). 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 | [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` 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]; ``` 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, 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. 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_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 | [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile) | `resolver` address ... [`valid=`time] [`ipv4=``on` | `off`] [`ipv6=``on` | `off`] [`status_zone=`zone]; | |-------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------| | Padrão | — | | [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. #### 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. Se for repetida, a última definição terá efeito. Por padrão, o Angie faz cache das respostas usando o valor TTL de uma resposta. Se a diretiva `resolver` não for especificada e nenhuma consulta DNS dinâmica for realizada (por exemplo, ao usar nomes fixos em [Proxy](https://pt.angie.software//angie/docs/configuration/modules/http/http_proxy.md#http-proxy) sem variáveis), especificar um resolver não é necessário: os nomes serão resolvidos na inicialização usando o resolver do sistema. 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
([/status/resolvers/](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-status-resolvers))
na zona especificada | |-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| ### 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; ``` ### error_log_user_tag | [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 solicitação aos registros do log de erros. O value é um [valor complexo](https://pt.angie.software//angie/docs/configuration/configfile.md#syntax) e pode usar variáveis. A diretiva pode ser especificada várias vezes para adicionar múltiplas tags. Tags podem ser correspondidas com `filter=tag:` em [error_log](https://pt.angie.software//angie/docs/configuration/modules/core.md#error-log). ### 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. ### 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 | [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. ### 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. ### 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 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. 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 | [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_` 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` 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 ### `$time_iso8601` hora local no formato padrão ISO 8601 ### `$time_local` hora local no formato Common Log Format ### `$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` ### `$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#id4), ao fazer redirecionamentos internos ou ao usar arquivos de índice.