<!-- review: finished -->

<a id="http-fastcgi"></a>

# FastCGI

O módulo permite passar requisições para um servidor FastCGI.

<a id="configuration-example-14"></a>

## Exemplo de Configuração

```nginx
location / {
    fastcgi_pass  localhost:9000;
    fastcgi_index index.php;

    fastcgi_param SCRIPT_FILENAME /home/www/scripts/php$fastcgi_script_name;
    fastcgi_param QUERY_STRING    $query_string;
    fastcgi_param REQUEST_METHOD  $request_method;
    fastcgi_param CONTENT_TYPE    $content_type;
    fastcgi_param CONTENT_LENGTH  $content_length;
}
```

<a id="directives-15"></a>

## Diretivas

<a id="index-0"></a>

<a id="fastcgi-bind"></a>

### fastcgi_bind

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_bind` address [`transparent`] | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------------|
| Padrão                                                                                    | —                                                 |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                            |

Faz com que conexões de saída para um servidor FastCGI se originem do endereço IP local especificado com uma porta opcional. O valor do parâmetro pode conter variáveis. O valor especial `off` cancela o efeito da diretiva fastcgi_bind herdada do nível de configuração anterior, o que permite ao sistema atribuir automaticamente o endereço IP local e a porta.

O parâmetro `transparent` permite que conexões de saída para um servidor FastCGI se originem de um endereço IP não-local, por exemplo, de um endereço IP real de um cliente:

```nginx
fastcgi_bind $remote_addr transparent;
```

Para que este parâmetro funcione,
os processos worker do Angie geralmente precisam executar
com privilégios de [superusuário](https://pt.angie.software//angie/docs/configuration/modules/core.md#user).
No Linux, isso não é necessário:
se o parâmetro `transparent` for especificado,
os processos worker herdam a capacidade CAP_NET_RAW do processo mestre.

#### NOTE
A tabela de roteamento do kernel também deve ser configurada
para interceptar o tráfego de rede do servidor FastCGI.

<a id="index-1"></a>

<a id="fastcgi-buffer-size"></a>

### fastcgi_buffer_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_buffer_size` size;   |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão                                                                                    | `fastcgi_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 ler a primeira parte da resposta recebida do servidor FastCGI. Esta parte geralmente contém um pequeno cabeçalho de resposta. 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.

<a id="index-2"></a>

<a id="fastcgi-buffering"></a>

### fastcgi_buffering

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_buffering` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão                                                                                    | `fastcgi_buffering on;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location              |

Habilita ou desabilita o buffering de respostas do servidor FastCGI.

| `on`   | O Angie recebe uma resposta do servidor FastCGI o mais rápido possível, salvando-a nos buffers definidos pelas diretivas [fastcgi_buffer_size](#fastcgi-buffer-size) e [fastcgi_buffers](#fastcgi-buffers). O envio ao cliente é realizado em paralelo: buffers preenchidos são passados para envio, mas seu tamanho total é limitado por [fastcgi_busy_buffers_size](#fastcgi-busy-buffers-size). Se um buffer não estiver totalmente preenchido, ele não é passado para envio, a menos que contenha a última parte da resposta. Portanto, a leitura com buffering não é adequada quando você precisa de entrega imediata de cada poucos bytes. Se toda a resposta não couber na memória, uma parte dela pode ser salva em um [arquivo temporário](#fastcgi-temp-path) no disco. A escrita em arquivos temporários é controlada pelas diretivas [fastcgi_max_temp_file_size](#fastcgi-max-temp-file-size) e [fastcgi_temp_file_write_size](#fastcgi-temp-file-write-size).   |
|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | A resposta é passada para o cliente imediatamente conforme é recebida. O Angie trabalha em um ciclo "ler — enviar" e não espera o buffer encher completamente: por exemplo, 10 bytes lidos de um buffer de 4K são enviados imediatamente. Ao mesmo tempo, se a resposta inteira couber no buffer, o Angie pode lê-la por completo. O tamanho máximo dos dados que o Angie pode receber do servidor de uma vez é definido pela diretiva [fastcgi_buffer_size](#fastcgi-buffer-size). Com `off`, [fastcgi_limit_rate](#fastcgi-limit-rate) não funciona.                                                                                                                                                                                                                                                                                                                                                                                                                        |

O buffering também pode ser habilitado ou desabilitado passando "yes" ou "no" no campo de cabeçalho de resposta `X-Accel-Buffering`. Esta capacidade pode ser desabilitada usando a diretiva [fastcgi_ignore_headers](#fastcgi-ignore-headers).

<a id="index-3"></a>

<a id="fastcgi-buffers"></a>

### fastcgi_buffers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_buffers` number size;   |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão                                                                                    | `fastcgi_buffers 8 4k|8k;`       |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location           |

Define o número e tamanho dos buffers usados para ler uma resposta do servidor FastCGI, para uma única conexão.

Por padrão, o tamanho do buffer é igual a uma página de memória. Isso é 4K ou 8K, dependendo da plataforma.

<a id="index-4"></a>

<a id="fastcgi-busy-buffers-size"></a>

### fastcgi_busy_buffers_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_busy_buffers_size` size;   |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão                                                                                    | `fastcgi_busy_buffers_size 8k|16k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location              |

Quando o [buffering](#fastcgi-buffering) de respostas do servidor FastCGI está habilitado, limita o tamanho total dos buffers que podem estar ocupados enviando uma resposta para o cliente enquanto a resposta ainda não foi totalmente lida. Enquanto isso, o resto dos buffers pode ser usado para ler a resposta e, se necessário, armazenar parte da resposta em buffer em um arquivo temporário. Por padrão, o tamanho é limitado pelo tamanho de dois buffers definidos pelas diretivas [fastcgi_buffer_size](#fastcgi-buffer-size) e [fastcgi_buffers](#fastcgi-buffers).

<a id="index-5"></a>

<a id="fastcgi-cache"></a>

### fastcgi_cache

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache` zone | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão                                                                                    | `fastcgi_cache off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location          |

Define uma zona de memória compartilhada usada para cache. A mesma zona pode ser usada em vários lugares. O valor do parâmetro pode conter variáveis. O parâmetro `off` desabilita o cache herdado do nível de configuração anterior.

<a id="index-6"></a>

<a id="fastcgi-cache-background-update"></a>

### fastcgi_cache_background_update

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_background_update` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_background_update off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                            |

Permite iniciar uma sub-requisição em segundo plano para atualizar um item de cache expirado, enquanto uma resposta em cache obsoleta é retornada ao cliente. Note que é necessário [permitir](#fastcgi-cache-use-stale-updating) o uso de uma resposta em cache obsoleta quando ela está sendo atualizada.

<a id="index-7"></a>

<a id="fastcgi-cache-bypass"></a>

### fastcgi_cache_bypass

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_bypass` 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 não será obtida de um cache. Se pelo menos um valor dos parâmetros string não estiver vazio e não for igual a "0", então a resposta não será obtida do cache:

```nginx
fastcgi_cache_bypass $cookie_nocache $arg_nocache$arg_comment;
fastcgi_cache_bypass $http_pragma    $http_authorization;
```

Pode ser usado junto com a diretiva [fastcgi_no_cache](#fastcgi-no-cache).

<a id="index-8"></a>

<a id="fastcgi-cache-key"></a>

### fastcgi_cache_key

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_key` string;   |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão                                                                                    | —                             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location        |

Define uma chave para cache, por exemplo

```nginx
fastcgi_cache_key localhost:9000$request_uri;
```

<a id="index-9"></a>

<a id="fastcgi-cache-lock"></a>

### fastcgi_cache_lock

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_lock` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_lock off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location               |

Quando habilitado, apenas uma requisição por vez será permitida para popular um novo elemento de cache identificado de acordo com a diretiva [fastcgi_cache_key](#fastcgi-cache-key) passando uma requisição para um servidor FastCGI. Outras requisições do mesmo elemento de cache irão aguardar uma resposta aparecer no cache ou o bloqueio de cache para este elemento ser liberado, até o tempo definido pela diretiva [fastcgi_cache_lock_timeout](#fastcgi-cache-lock-timeout).

<a id="index-10"></a>

<a id="fastcgi-cache-lock-age"></a>

### fastcgi_cache_lock_age

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_lock_age` time;   |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão                                                                                    | `fastcgi_cache_lock_age 5s;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location           |

Se a última requisição passada ao servidor FastCGI para popular um novo elemento de cache não foi completada no tempo especificado, uma outra requisição pode ser passada ao servidor FastCGI.

<a id="index-11"></a>

<a id="fastcgi-cache-lock-timeout"></a>

### fastcgi_cache_lock_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_lock_timeout` tempo;   |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_lock_timeout 5s;`      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                |

Define um timeout para [fastcgi_cache_lock](#fastcgi-cache-lock). Quando o tempo expira, a requisição será passada para o servidor FastCGI, porém, a resposta não será armazenada em cache.

<a id="index-12"></a>

<a id="fastcgi-cache-max-range-offset"></a>

### fastcgi_cache_max_range_offset

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_max_range_offset` número;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | —                                          |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                     |

Define um deslocamento em bytes para requisições de byte-range. Se o range estiver além do deslocamento, a requisição de range será passada para o servidor FastCGI e a resposta não será armazenada em cache.

<a id="index-13"></a>

<a id="fastcgi-cache-methods"></a>

### fastcgi_cache_methods

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_methods` `GET` | `HEAD` | `POST` ...;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_methods GET HEAD;`                      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                 |

Se o método de requisição do cliente estiver listado nesta diretiva, então a resposta será armazenada em cache. Os métodos "GET" e "HEAD" são sempre adicionados à lista, embora seja recomendado especificá-los explicitamente. Veja também a diretiva [fastcgi_no_cache](#fastcgi-no-cache).

<a id="index-14"></a>

<a id="fastcgi-cache-min-uses"></a>

### fastcgi_cache_min_uses

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_min_uses` número;   |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_min_uses 1;`        |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location             |

Define o número de requisições após o qual a resposta será armazenada em cache.

#### WARNING
Metadados do cache são armazenados em memória compartilhada. Excluir manualmente arquivos de cache não
redefine os contadores e pode levar a comportamento imprevisível. Para
redefinir completamente o cache, pare o servidor, exclua o diretório de cache e inicie novamente.

#### NOTE
Módulos de limpeza de cache de terceiros (por exemplo, [Cache Purge](https://pt.angie.software//angie/docs/installation/external-modules/cache-purge.md#external-cache-purge)) apenas excluem
arquivos mas não redefinem o contador fastcgi_cache_min_uses. A diretiva
é destinada a proteger o cache de poluição por requisições infrequentes, e redefinir
o contador na limpeza pode afetar negativamente o desempenho.

<a id="index-15"></a>

<a id="fastcgi-cache-path"></a>

### fastcgi_cache_path

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_path` caminho [`levels=`níveis] [`use_temp_path=``on` | `off`] `keys_zone=`nome:tamanho [`inactive=`tempo] [`max_size=`tamanho] [`min_free=`tamanho] [`manager_files=`número] [`manager_sleep=`tempo] [`manager_threshold=`tempo] [`loader_files=`número] [`loader_sleep=`tempo] [`loader_threshold=`tempo];   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | —                                                                                                                                                                                                                                                                                                                             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                                                                                                                                                                                                                                                        |

Define o caminho e outros parâmetros de um cache. Os dados do cache são armazenados em arquivos. Tanto a chave quanto o nome do arquivo em um cache são resultado da aplicação da função MD5 à URL proxificada.

O parâmetro `levels` define os níveis hierárquicos de um cache: de 1 a 3, cada nível aceita valores 1 ou 2. Por exemplo, na seguinte configuração

```nginx
fastcgi_cache_path /data/angie/cache levels=1:2 keys_zone=one:10m;
```

os nomes de arquivo em um cache ficarão assim:

```nginx
/data/angie/cache/c/29/b7f54b2df7773722d382f4809d65029c
```

Uma resposta em cache é primeiro escrita em um arquivo temporário, e então o arquivo é renomeado. Arquivos temporários e o cache podem ser colocados em sistemas de arquivos diferentes. No entanto, esteja ciente de que neste caso um arquivo é copiado entre dois sistemas de arquivos em vez da operação barata de renomeação. É portanto recomendado que para qualquer localização dada tanto o cache quanto um diretório contendo arquivos temporários sejam colocados no mesmo sistema de arquivos.

Um diretório para arquivos temporários é definido baseado no parâmetro `use_temp_path`.

| `on`   | Se este parâmetro for omitido ou definido com o valor `on`, o diretório definido pela diretiva [fastcgi_temp_path](#fastcgi-temp-path) para a localização dada será usado.   |
|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | arquivos temporários serão colocados diretamente no diretório de cache.                                                                                                      |

Além disso, todas as chaves ativas e informações sobre dados são armazenadas em uma zona de memória compartilhada, cujo nome e tamanho são configurados pelo parâmetro `keys_zone`. Uma zona de um megabyte pode armazenar cerca de 8 mil chaves. Metadados do cache são armazenados em memória compartilhada.

Dados em cache que não são acessados durante o tempo especificado pelo parâmetro `inactive` são removidos do cache independentemente de sua atualidade.

Por padrão, `inactive` é definido como 10 minutos.

Um processo especial **gerenciador de cache** monitora o tamanho máximo do cache e a quantidade mínima de espaço livre no sistema de arquivos com cache. Quando o tamanho é excedido ou não há espaço livre suficiente, ele remove os dados menos recentemente usados. Os dados são removidos em iterações.

| `max_size`          | tamanho máximo do cache                                                                     |
|---------------------|---------------------------------------------------------------------------------------------|
| `min_free`          | quantidade mínima de espaço livre no sistema de arquivos com cache                          |
| `manager_files`     | limita o número de itens a serem excluídos durante uma iteração<br/><br/>Por padrão, `100`. |
| `manager_threshold` | limita a duração de uma iteração<br/><br/>Por padrão, `200` milissegundos                   |
| `manager_sleep`     | configura uma pausa entre iterações<br/><br/>Por padrão, `50` milissegundos                 |

Um minuto após o Angie iniciar, o processo especial **carregador de cache** é ativado. Ele carrega informações sobre dados previamente armazenados em cache no sistema de arquivos em uma zona de cache. O carregamento também é feito em iterações.

| `loader_files`     | número máximo de itens de cache a carregar em uma iteração<br/><br/>Padrão: `100`       |
|--------------------|-----------------------------------------------------------------------------------------|
| `loader_threshold` | limita o tempo de uma iteração<br/><br/>Padrão: `200` milissegundos                     |
| `loader_sleep`     | tempo pelo qual uma pausa é mantida entre iterações<br/><br/>Padrão: `50` milissegundos |

<a id="index-16"></a>

<a id="fastcgi-cache-revalidate"></a>

### fastcgi_cache_revalidate

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_revalidate` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_revalidate off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                     |

Habilita a revalidação de itens de cache expirados usando requisições condicionais com os campos de cabeçalho `If-Modified-Since` e `If-None-Match`.

<a id="index-17"></a>

<a id="fastcgi-cache-use-stale"></a>

### fastcgi_cache_use_stale

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_use_stale` `error` | `timeout` | `invalid_header` | `updating` | `http_500` | `http_503` | `http_403` | `http_429` | `off` ...;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `fastcgi_cache_use_stale off;`                                                                                                                   |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                                                                           |

Determina em quais casos uma resposta em cache obsoleta pode ser usada quando ocorre um erro durante a comunicação com o servidor FastCGI. Os parâmetros da diretiva correspondem aos parâmetros da diretiva [fastcgi_next_upstream](#fastcgi-next-upstream).

| `error`    | permite usar uma resposta em cache obsoleta se um servidor FastCGI não puder ser selecionado para processar uma requisição.                                                                                       |
|------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `updating` | um parâmetro adicional que permite usar uma resposta em cache obsoleta se ela estiver sendo atualizada no momento. Isso permite minimizar o número de acessos aos servidores FastCGI ao atualizar dados em cache. |

O uso de uma resposta em cache obsoleta também pode ser permitido diretamente no cabeçalho de resposta por um número especificado de segundos após a resposta ter se tornado obsoleta.

* A extensão [stale-while-revalidate](https://datatracker.ietf.org/doc/html/rfc5861#section-3) do campo de cabeçalho `Cache-Control` permite usar uma resposta em cache obsoleta se ela estiver sendo atualizada no momento.
* A extensão [stale-if-error](https://datatracker.ietf.org/doc/html/rfc5861#section-4) do campo de cabeçalho `Cache-Control` permite usar uma resposta em cache obsoleta em caso de erro.

#### NOTE
Este método tem prioridade menor do que definir os parâmetros da diretiva.

Para minimizar o número de acessos aos servidores FastCGI ao popular um novo elemento de cache, a diretiva [fastcgi_cache_lock](#fastcgi-cache-lock) pode ser usada.

<a id="index-18"></a>

<a id="fastcgi-cache-valid"></a>

### fastcgi_cache_valid

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_cache_valid` [código ...] tempo;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão                                                                                    | —                                           |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                      |

Define o tempo de cache para diferentes códigos de resposta. Por exemplo, as seguintes diretivas

```nginx
fastcgi_cache_valid 200 302 10m;
fastcgi_cache_valid 404      1m;
```

definem 10 minutos de cache para respostas com códigos 200 e 302 e 1 minuto para respostas com código 404.

Se apenas o tempo de cache for especificado,

```nginx
fastcgi_cache_valid 5m;
```

então apenas respostas 200, 301 e 302 são armazenadas em cache.

Além disso, pode ser especificado armazenar em cache qualquer resposta usando o parâmetro `any`:

```nginx
fastcgi_cache_valid 200 302 10m;
fastcgi_cache_valid 301      1h;
fastcgi_cache_valid any      1m;
```

#### NOTE
Parâmetros de cache também podem ser definidos diretamente no cabeçalho de resposta. Isso tem prioridade mais alta que a configuração do tempo de cache usando a diretiva.

* O campo de cabeçalho `X-Accel-Expires` define o tempo de cache de uma resposta em segundos. O valor zero desabilita o cache para uma resposta. Se o valor começar com o prefixo @, ele define um tempo absoluto em segundos desde a Época, até o qual a resposta pode ser armazenada em cache.
* Se o cabeçalho não incluir o campo `X-Accel-Expires`, parâmetros de cache podem ser definidos nos campos de cabeçalho `Expires` ou `Cache-Control`.
* Se o cabeçalho incluir o campo `Set-Cookie`, tal resposta não será armazenada em cache.
* Se o cabeçalho incluir o campo `Vary` com o valor especial "\*", tal resposta não será armazenada em cache. Se o cabeçalho incluir o campo `Vary` com outro valor, tal resposta será armazenada em cache levando em conta os campos de cabeçalho de solicitação correspondentes.

O processamento de um ou mais desses campos de cabeçalho de resposta pode ser desabilitado usando a diretiva [fastcgi_ignore_headers](#fastcgi-ignore-headers).

<a id="index-19"></a>

<a id="fastcgi-catch-stderr"></a>

### fastcgi_catch_stderr

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_catch_stderr` string;   |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão                                                                                    | —                                |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location           |

Define uma string para buscar no fluxo de erro de uma resposta recebida de um servidor FastCGI. Se a string for encontrada, então é considerado que o servidor FastCGI retornou uma resposta [inválida](#fastcgi-next-upstream). Isso permite lidar com erros de aplicação no Angie, por exemplo:

```nginx
location /php/ {
    fastcgi_pass backend:9000;
    ...
    fastcgi_catch_stderr "PHP Fatal error";
    fastcgi_next_upstream error timeout invalid_header;
}
```

<a id="index-20"></a>

<a id="fastcgi-connect-timeout"></a>

### fastcgi_connect_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_connect_timeout` tempo;   |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão                                                                                    | `fastcgi_connect_timeout 60s;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location             |

Define um timeout para estabelecer uma conexão com um servidor FastCGI. Deve-se notar que este timeout geralmente não pode exceder 75 segundos.

<a id="index-21"></a>

<a id="fastcgi-connection-drop"></a>

### fastcgi_connection_drop

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_connection_drop` tempo | `on` | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------------|
| Padrão                                                                                    | `fastcgi_connection_drop off;`                    |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                            |

Habilita o encerramento de todas as conexões para o servidor proxy após ele ter sido
removido do grupo ou marcado como permanentemente indisponível por um processo de [reresolve](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve) ou pelo [comando da API](https://pt.angie.software//angie/docs/configuration/modules/http/http_api.md#api-config-methods)
`DELETE`.

Uma conexão é encerrada quando o próximo evento de leitura ou escrita é processado para
o cliente ou o servidor proxy.

Definir tempo habilita um [timeout](https://pt.angie.software//angie/docs/configuration/configfile.md#syntax) de encerramento de conexão;
com `on` definido, as conexões são descartadas imediatamente.

<a id="index-22"></a>

<a id="fastcgi-force-ranges"></a>

### fastcgi_force_ranges

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_force_ranges` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão                                                                                    | `fastcgi_force_ranges off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                 |

Habilita suporte a byte-range para respostas em cache e não armazenadas em cache do servidor FastCGI, independentemente do campo `Accept-Ranges` nessas respostas.

<a id="index-23"></a>

<a id="fastcgi-hide-header"></a>

### fastcgi_hide_header

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_hide_header` campo;   |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão                                                                                    | —                              |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location         |

Por padrão, o Angie não passa os campos de cabeçalho `Status` e `X-Accel-...` da resposta de um servidor FastCGI para um cliente. A diretiva `fastcgi_hide_header` define campos adicionais que não serão passados. Se, ao contrário, a passagem de campos precisar ser permitida, a diretiva [fastcgi_pass_header](#fastcgi-pass-header) pode ser usada.

<a id="index-24"></a>

<a id="fastcgi-ignore-client-abort"></a>

### fastcgi_ignore_client_abort

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_ignore_client_abort` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------|
| Padrão                                                                                    | `fastcgi_ignore_client_abort off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                        |

Determina se a conexão com um servidor FastCGI deve ser fechada quando um cliente fecha a conexão sem aguardar uma resposta.

<a id="index-25"></a>

<a id="fastcgi-ignore-headers"></a>

### fastcgi_ignore_headers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_ignore_headers` campo;   |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão                                                                                    | —                                 |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location            |

Desabilita o processamento de certos campos de cabeçalho de resposta do servidor FastCGI. Os seguintes campos podem ser ignorados: `X-Accel-Redirect`, `X-Accel-Expires`, `X-Accel-Limit-Rate`, `X-Accel-Buffering`, `X-Accel-Charset`, `Expires`, `Cache-Control`, `Set-Cookie` e `Vary`.

Se não desabilitado, o processamento desses campos de cabeçalho tem o seguinte efeito:

* `X-Accel-Expires`, `Expires`, `Cache-Control`, `Set-Cookie` e `Vary` definem os [parâmetros](#fastcgi-cache-valid) de cache de resposta;
* `X-Accel-Redirect` executa um [redirecionamento interno](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#internal) para o URI especificado;
* `X-Accel-Limit-Rate` define o [limite de taxa](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#limit-rate) para transmissão de uma resposta para um cliente;
* `X-Accel-Buffering` habilita ou desabilita o [buffering](#fastcgi-buffering) de uma resposta;
* `X-Accel-Charset` define o [charset](https://pt.angie.software//angie/docs/configuration/modules/http/http_charset.md#id1) desejado de uma resposta.

<a id="index-26"></a>

<a id="fastcgi-index"></a>

### fastcgi_index

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_index` nome;   |
|-------------------------------------------------------------------------------------------|-------------------------|
| Padrão                                                                                    | —                       |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location  |

Define um nome de arquivo que será anexado após um URI que termina com uma barra, no valor da variável [$fastcgi_script_name](#v-fastcgi-script-name). Por exemplo, com essas configurações

```nginx
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /home/www/scripts/php$fastcgi_script_name;
```

e a requisição `/page.php`, o parâmetro `SCRIPT_FILENAME` será igual a `/home/www/scripts/php/page.php`, e com a requisição `/` será igual a `/home/www/scripts/php/index.php`.

<a id="index-27"></a>

<a id="fastcgi-intercept-errors"></a>

### fastcgi_intercept_errors

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_intercept_errors` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | `fastcgi_intercept_errors off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                     |

Determina se respostas do servidor FastCGI com códigos maiores ou iguais a 300 devem ser passadas para um cliente ou serem interceptadas e redirecionadas para o Angie para processamento com a diretiva [error_page](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#error-page).

<a id="index-28"></a>

<a id="fastcgi-keep-conn"></a>

### fastcgi_keep_conn

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_keep_conn` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão                                                                                    | `fastcgi_keep_conn off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location              |

Por padrão, um servidor FastCGI fechará uma conexão logo após enviar a resposta. No entanto, quando esta diretiva é definida com o valor `on`, o Angie instruirá um servidor FastCGI a manter as conexões abertas. Isso é necessário, em particular, para que conexões [keepalive](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#u-keepalive) para servidores FastCGI funcionem.

<a id="index-29"></a>

<a id="fastcgi-limit-rate"></a>

### fastcgi_limit_rate

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_limit_rate` taxa;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão                                                                                    | `fastcgi_limit_rate 0;`      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location       |

Limita a velocidade de leitura da resposta do servidor proxy.
A taxa é especificada em bytes por segundo; variáveis podem ser usadas.

| `0`   | desabilita a limitação de taxa   |
|-------|----------------------------------|

#### NOTE
O limite é definido por requisição, e assim se o Angie abrir simultaneamente duas conexões para o servidor FastCGI, a taxa geral será duas vezes maior que o limite especificado. A limitação funciona apenas se o [buffering](#fastcgi-buffering) de respostas do servidor FastCGI estiver habilitado.

<a id="index-30"></a>

<a id="fastcgi-max-temp-file-size"></a>

### fastcgi_max_temp_file_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_max_temp_file_size` tamanho;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão                                                                                    | `fastcgi_max_temp_file_size 1024m;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                  |

Quando o [buffering](#fastcgi-buffering) de respostas do servidor FastCGI está habilitado, e a resposta inteira não cabe nos buffers definidos pelas diretivas [fastcgi_buffer_size](#fastcgi-buffer-size) e [fastcgi_buffers](#fastcgi-buffers), uma parte da resposta pode ser salva em um arquivo temporário. Esta diretiva define o tamanho máximo do arquivo temporário. O tamanho dos dados escritos no arquivo temporário por vez é definido pela diretiva [fastcgi_temp_file_write_size](#fastcgi-temp-file-write-size).

| `0`   | desabilita o buffering de respostas para arquivos temporários   |
|-------|-----------------------------------------------------------------|

#### NOTE
Esta restrição não se aplica a respostas que serão [armazenadas em cache](#fastcgi-cache) ou [armazenadas](#fastcgi-store) em disco.

<a id="index-31"></a>

<a id="fastcgi-next-upstream"></a>

### fastcgi_next_upstream

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_next_upstream` `error` | `timeout` | `invalid_header` | `http_500` | `http_503` | `http_403` | `http_404` | `http_429` | `non_idempotent` | `off` ...;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `fastcgi_next_upstream error timeout;`                                                                                                                            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                                                                                            |

Especifica em quais casos uma requisição deve ser passada para o próximo servidor:

| `error`          | ocorreu um erro ao estabelecer uma conexão com o servidor, passar uma requisição para ele, ou ler o cabeçalho da resposta;                                                                                                                                                                                                                   |
|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `timeout`        | ocorreu um timeout ao estabelecer uma conexão com o servidor, passar uma requisição para ele, ou ler o cabeçalho da resposta;                                                                                                                                                                                                                |
| `invalid_header` | um servidor retornou uma resposta vazia ou inválida;                                                                                                                                                                                                                                                                                         |
| `http_500`       | um servidor retornou uma resposta com o código 500;                                                                                                                                                                                                                                                                                          |
| `http_503`       | um servidor retornou uma resposta com o código 503;                                                                                                                                                                                                                                                                                          |
| `http_403`       | um servidor retornou uma resposta com o código 403;                                                                                                                                                                                                                                                                                          |
| `http_404`       | um servidor retornou uma resposta com o código 404;                                                                                                                                                                                                                                                                                          |
| `http_429`       | um servidor retornou uma resposta com o código 429;                                                                                                                                                                                                                                                                                          |
| `non_idempotent` | normalmente, requisições com um método [não-idempotente](https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.2)<br/>(`POST`, `LOCK`, `PATCH`) não são passadas para o próximo<br/>servidor se uma requisição foi enviada para um servidor upstream; habilitar esta<br/>opção permite explicitamente tentar novamente tais requisições; |
| `off`            | desabilita passar uma requisição para o próximo servidor.                                                                                                                                                                                                                                                                                    |

#### NOTE
Deve-se ter em mente que passar uma requisição para o próximo servidor só é possível se nada foi enviado para um cliente ainda. Ou seja, se um erro ou timeout ocorre no meio da transferência de uma resposta, corrigir isso é impossível.

A diretiva também define o que é considerado uma [tentativa mal-sucedida](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#max-fails) de comunicação com um servidor.

| `error`<br/><br/>`timeout`<br/><br/>`invalid_header`   | sempre consideradas tentativas mal-sucedidas, mesmo se não estão especificadas na diretiva   |
|--------------------------------------------------------|----------------------------------------------------------------------------------------------|
| `http_500`<br/><br/>`http_503`<br/><br/>`http_429`     | consideradas tentativas mal-sucedidas apenas se estão especificadas na diretiva              |
| `http_403`<br/><br/>`http_404`                         | nunca consideradas tentativas mal-sucedidas                                                  |

Passar uma requisição para o próximo servidor pode ser limitado pelo [número de tentativas](#fastcgi-next-upstream-tries) e por [tempo](#fastcgi-next-upstream-timeout).

<a id="index-32"></a>

<a id="fastcgi-next-upstream-timeout"></a>

### fastcgi_next_upstream_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_next_upstream_timeout` tempo;   |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão                                                                                    | `fastcgi_next_upstream_timeout 0;`       |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                   |

Limita o tempo durante o qual uma requisição pode ser passada para o [próximo servidor](#fastcgi-next-upstream).

| `0`   | desativa esta limitação   |
|-------|---------------------------|

<a id="index-33"></a>

<a id="fastcgi-next-upstream-tries"></a>

### fastcgi_next_upstream_tries

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_next_upstream_tries` número;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão                                                                                    | `fastcgi_next_upstream_tries 0;`        |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                  |

Limita o número de tentativas possíveis para passar uma requisição para o [próximo servidor](#fastcgi-next-upstream).

| `0`   | desativa esta limitação   |
|-------|---------------------------|

<a id="index-34"></a>

<a id="fastcgi-no-cache"></a>

### fastcgi_no_cache

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_no_cache` 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 não será salva em um cache. Se pelo menos um valor dos parâmetros string não estiver vazio e não for igual a "0", então a resposta não será salva:

```nginx
fastcgi_no_cache $cookie_nocache $arg_nocache$arg_comment;
fastcgi_no_cache $http_pragma    $http_authorization;
```

Pode ser usada junto com a diretiva [fastcgi_cache_bypass](#fastcgi-cache-bypass).

<a id="index-35"></a>

<a id="fastcgi-param"></a>

### fastcgi_param

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_param` parâmetro valor [`if_not_empty`];   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------|
| Padrão                                                                                    | —                                                   |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                              |

Define um parâmetro que deve ser passado para o servidor FastCGI. O valor pode conter texto, variáveis e sua combinação. Essas diretivas são herdadas do nível de configuração anterior se e somente se não há diretivas fastcgi_param definidas no nível atual.

#### NOTE
Nos arquivos padrão `fastcgi.conf` e `fastcgi_params` fornecidos
com o Angie, `REQUEST_METHOD` é definido como `$upstream_request_method`.
Isso garante que quando o cache converte `HEAD` para `GET`, o
método de requisição upstream reflete essa conversão.

O exemplo a seguir mostra as configurações mínimas necessárias para PHP:

```nginx
fastcgi_param SCRIPT_FILENAME /home/www/scripts/php$fastcgi_script_name;
fastcgi_param QUERY_STRING    $query_string;
```

O parâmetro SCRIPT_FILENAME é usado no PHP para determinar o nome do script, e o parâmetro QUERY_STRING é usado para passar parâmetros de requisição.

Para scripts que processam requisições POST, os três parâmetros a seguir também são necessários:

```nginx
fastcgi_param REQUEST_METHOD  $request_method;
fastcgi_param CONTENT_TYPE    $content_type;
fastcgi_param CONTENT_LENGTH  $content_length;
```

Se o PHP foi compilado com o parâmetro de configuração `--enable-force-cgi-redirect`, o parâmetro REDIRECT_STATUS também deve ser passado com o valor "200":

```nginx
fastcgi_param REDIRECT_STATUS 200;
```

Se a diretiva for especificada com `if_not_empty`, então tal parâmetro será passado para o servidor apenas se seu valor não estiver vazio:

```nginx
fastcgi_param HTTPS           $https if_not_empty;
```

<a id="index-36"></a>

<a id="fastcgi-pass"></a>

### fastcgi_pass

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_pass` endereço;   |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão                                                                                    | —                          |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location, if in location   |

Define o endereço de um servidor FastCGI. O endereço pode ser especificado como um nome de domínio ou endereço IP, e uma porta:

```nginx
fastcgi_pass localhost:9000;
```

ou como um caminho de socket de domínio UNIX:

```nginx
fastcgi_pass unix:/tmp/fastcgi.socket;
```

Se um nome de domínio resolve para vários endereços, todos eles serão usados de forma round-robin. Além disso, um endereço pode ser especificado como um [grupo de servidores](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream).

Valores de parâmetros podem conter variáveis. Neste caso, se um endereço é especificado como um nome de domínio, o nome é procurado entre os [grupos de servidores](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream) descritos, e, se não for encontrado, é determinado usando um [resolver](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#resolver).

#### NOTE
If `fastcgi_pass` is placed in a `location` whose prefix ends with a slash
(for example, `location /name/`),
and the [auto_redirect](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#auto-redirect) directive is set to `default`,
requests without a trailing slash will be redirected (`/name -> /name/`).

<a id="index-37"></a>

<a id="fastcgi-pass-header"></a>

### fastcgi_pass_header

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_pass_header` campo;   |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão                                                                                    | —                              |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location         |

Permite passar campos de cabeçalho [de outra forma desabilitados](#fastcgi-hide-header) de um servidor FastCGI para um cliente.

<a id="index-38"></a>

<a id="fastcgi-pass-request-body"></a>

### fastcgi_pass_request_body

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_pass_request_body` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão                                                                                    | `fastcgi_pass_request_body on;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                      |

Indica se o corpo da requisição original é passado para o servidor FastCGI. Veja também a diretiva [fastcgi_pass_request_headers](#fastcgi-pass-request-headers).

<a id="index-39"></a>

<a id="fastcgi-pass-request-headers"></a>

### fastcgi_pass_request_headers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_pass_request_headers` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|------------------------------------------------|
| Padrão                                                                                    | `fastcgi_pass_request_headers on;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                         |

Indica se os campos de cabeçalho da requisição original são passados para o servidor FastCGI. Veja também a diretiva [fastcgi_pass_request_body](#fastcgi-pass-request-body).

<a id="index-40"></a>

<a id="fastcgi-read-timeout"></a>

### fastcgi_read_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_read_timeout` tempo;   |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão                                                                                    | `fastcgi_read_timeout 60s;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location          |

Define um timeout para leitura de uma resposta do servidor FastCGI. O timeout é definido apenas entre duas operações de leitura sucessivas, não para a transmissão de toda a resposta. Se o servidor FastCGI não transmitir nada dentro deste tempo, a conexão é fechada.

<a id="index-41"></a>

<a id="fastcgi-request-buffering"></a>

### fastcgi_request_buffering

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_request_buffering` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão                                                                                    | `fastcgi_request_buffering on;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                      |

Habilita ou desabilita o buffering de um corpo de requisição do cliente.

| `on`   | o corpo inteiro da requisição é [lido](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#client-body-buffer-size) do cliente antes de enviar a requisição para um servidor FastCGI.                                      |
|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | o corpo da requisição é enviado para o servidor FastCGI imediatamente conforme é recebido. Neste caso, a requisição não pode ser passada para o [próximo servidor](#fastcgi-next-upstream) se o Angie já começou a enviar o corpo da requisição. |

<a id="index-42"></a>

<a id="fastcgi-send-lowat"></a>

### fastcgi_send_lowat

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_send_lowat` tamanho;   |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão                                                                                    | `fastcgi_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 em conexões de saída para um servidor FastCGI usando o 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, com o tamanho especificado.

#### NOTE
Esta diretiva é ignorada em Linux, Solaris e Windows.

<a id="index-43"></a>

<a id="fastcgi-send-timeout"></a>

### fastcgi_send_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_send_timeout` tempo;   |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão                                                                                    | `fastcgi_send_timeout 60s;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location          |

Define um timeout para transmitir uma requisição para o servidor FastCGI. O timeout é definido apenas entre duas operações de escrita sucessivas, não para a transmissão de toda a requisição. Se o servidor FastCGI não receber nada dentro deste tempo, a conexão é fechada.

<a id="index-44"></a>

<a id="fastcgi-socket-keepalive"></a>

### fastcgi_socket_keepalive

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_socket_keepalive` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | `fastcgi_socket_keepalive off;`            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                     |

Configura o comportamento "TCP keepalive" para conexões de saída para um servidor FastCGI.

| `off`   | Por padrão, as configurações do sistema operacional estão em vigor para o socket.   |
|---------|-------------------------------------------------------------------------------------|
| `on`    | a opção de socket SO_KEEPALIVE é ativada para o socket.                             |

<a id="index-45"></a>

<a id="fastcgi-split-path-info"></a>

### fastcgi_split_path_info

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_split_path_info` regex;   |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão                                                                                    | —                                  |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location                           |

Define uma expressão regular que captura um valor para a variável [$fastcgi_path_info](#v-fastcgi-path-info). A expressão regular deve ter duas capturas: a primeira se torna um valor da variável [$fastcgi_script_name](#v-fastcgi-script-name), a segunda se torna um valor da variável [$fastcgi_path_info](#v-fastcgi-path-info). Por exemplo, com estas configurações

```default
location ~ ^(.+\.php)(.*)$ {
    fastcgi_split_path_info       ^(.+\.php)(.*)$;
    fastcgi_param SCRIPT_FILENAME /path/to/php$fastcgi_script_name;
    fastcgi_param PATH_INFO       $fastcgi_path_info;
```

e a requisição `/show.php/article/0001`, o parâmetro SCRIPT_FILENAME será igual a `/path/to/php/show.php`,
e o parâmetro PATH_INFO será igual a `/article/0001`.

<a id="index-46"></a>

<a id="fastcgi-store"></a>

### fastcgi_store

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_store` `on` | `off` | string;   |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão                                                                                    | `fastcgi_store off;`                     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                   |

Habilita o salvamento de arquivos em disco.

| `on`   | salva arquivos com caminhos correspondentes às diretivas [alias](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#alias) ou [root](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#root).   |
|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | desabilita o salvamento de arquivos                                                                                                                                                                                                            |

Além disso, o nome do arquivo pode ser definido explicitamente usando a string com variáveis:

```nginx
fastcgi_store /data/www$original_uri;
```

O tempo de modificação dos arquivos é definido de acordo com o campo de cabeçalho de resposta `Last-Modified` recebido. A resposta é primeiro escrita em um arquivo temporário, e então o arquivo é renomeado. Arquivos temporários e o armazenamento persistente podem ser colocados em diferentes sistemas de arquivos. No entanto, esteja ciente de que neste caso um arquivo é copiado entre dois sistemas de arquivos em vez da operação barata de renomeação. Portanto, é recomendado que para qualquer localização dada, tanto os arquivos salvos quanto um diretório contendo arquivos temporários, definido pela diretiva [fastcgi_temp_path](#fastcgi-temp-path), sejam colocados no mesmo sistema de arquivos.

Esta diretiva pode ser usada para criar cópias locais de arquivos estáticos imutáveis, por exemplo:

```nginx
location /images/ {
    root                 /data/www;
    error_page           404 = /fetch$uri;
}

location /fetch/ {
    internal;

    fastcgi_pass         backend:9000;
    ...

    fastcgi_store        on;
    fastcgi_store_access user:rw group:rw all:r;
    fastcgi_temp_path    /data/temp;

    alias                /data/www/;
}
```

<a id="index-47"></a>

<a id="fastcgi-store-access"></a>

### fastcgi_store_access

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_store_access` users:permissions ...;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------|
| Padrão                                                                                    | `fastcgi_store_access user:rw;`                 |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                          |

Define permissões de acesso para arquivos e diretórios recém-criados, por exemplo:

```nginx
fastcgi_store_access user:rw group:rw all:r;
```

Se quaisquer permissões de acesso de grupo ou todos forem especificadas, então as permissões de usuário podem ser omitidas:

```nginx
fastcgi_store_access group:rw all:r;
```

<a id="index-48"></a>

<a id="fastcgi-temp-file-write-size"></a>

### fastcgi_temp_file_write_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_temp_file_write_size` size;   |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão                                                                                    | `fastcgi_temp_file_write_size 8k|16k;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                 |

Limita o tamanho dos dados escritos em um arquivo temporário por vez, quando o buffering de respostas do servidor FastCGI para arquivos temporários está habilitado. Por padrão, o tamanho é limitado por dois buffers definidos pelas diretivas [fastcgi_buffer_size](#fastcgi-buffer-size) e [fastcgi_buffers](#fastcgi-buffers). O tamanho máximo de um arquivo temporário é definido pela diretiva [fastcgi_max_temp_file_size](#fastcgi-max-temp-file-size).

<a id="index-49"></a>

<a id="fastcgi-temp-path"></a>

### fastcgi_temp_path

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `fastcgi_temp_path` path [level1 [level2 [level3]]]\`;                                                                                                                                                     |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `fastcgi_temp_path fastcgi_temp;`<br/>(o caminho depende do parâmetro de compilação `--http-fastcgi-temp-path` [build parameter](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths)) |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                                                                                                                                     |

Define um diretório para armazenar arquivos temporários com dados recebidos de servidores FastCGI. Até três níveis de hierarquia de subdiretórios podem ser usados abaixo do diretório especificado. Por exemplo, na seguinte configuração

```nginx
fastcgi_temp_path /spool/angie/fastcgi_temp 1 2;
```

um arquivo temporário pode parecer com isto:

```nginx
/spool/angie/fastcgi_temp/7/45/00000123457
```

Veja também o parâmetro use_temp_path da diretiva [fastcgi_cache_path](#fastcgi-cache-path).

<a id="parameters-passed-to-a-fastcgi-server"></a>

## Parâmetros Passados para um Servidor FastCGI

Campos de cabeçalho de requisição HTTP são passados para um servidor FastCGI como parâmetros. Em aplicações e scripts executados como servidores FastCGI, estes parâmetros geralmente estão disponíveis como variáveis de ambiente. Por exemplo, o campo de cabeçalho `User-Agent` é passado como o parâmetro HTTP_USER_AGENT. Além dos campos de cabeçalho de requisição HTTP, parâmetros arbitrários podem ser passados usando a diretiva [fastcgi_param](#fastcgi-param).

<a id="built-in-variables"></a>

## Variáveis Integradas

O módulo http_fastcgi suporta variáveis integradas que podem ser usadas para definir parâmetros usando a diretiva [fastcgi_param](#fastcgi-param):

<a id="v-fastcgi-script-name"></a>

### `$fastcgi_script_name`

URI da requisição ou, se uma URI termina com uma barra, URI da requisição com um nome de arquivo de índice configurado pela diretiva [fastcgi_index](#fastcgi-index) anexado a ela. Esta variável pode ser usada para definir os parâmetros SCRIPT_FILENAME e PATH_TRANSLATED que são usados, em particular, para determinar o nome do script em PHP. Por exemplo, para a requisição `/info/` com as seguintes diretivas

```nginx
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /home/www/scripts/php$fastcgi_script_name;
```

o parâmetro SCRIPT_FILENAME será igual a `/home/www/scripts/php/info/index.php`.

Ao usar a diretiva [fastcgi_split_path_info](#fastcgi-split-path-info), a variável $fastcgi_script_name é igual ao valor do primeiro grupo de captura definido por esta diretiva.

<a id="v-fastcgi-path-info"></a>

### `$fastcgi_path_info`

O valor do segundo grupo de captura definido pela diretiva [fastcgi_split_path_info](#fastcgi-split-path-info). Esta variável pode ser usada para definir o parâmetro PATH_INFO.