<!-- review: finished -->

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

# uWSGI

Permite passar requisições para um servidor uWSGI.

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

## Exemplo de Configuração

```nginx
location / {
    include    uwsgi_params;
    uwsgi_pass localhost:9000;
}
```

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

## Diretivas

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

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

### uwsgi_bind

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_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 uWSGI 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 uwsgi_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 uWSGI se originem de um endereço IP não-local, por exemplo, de um endereço IP real de um cliente:

```nginx
uwsgi_bind $remote_addr transparent;
```

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

#### NOTE
É necessário configurar a tabela de roteamento do kernel para interceptar o tráfego de rede do servidor uWSGI.

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

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

### uwsgi_buffer_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_buffer_size` size;   |
|-------------------------------------------------------------------------------------------|-----------------------------|
| Padrão                                                                                    | `uwsgi_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 uWSGI. 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="uwsgi-buffering"></a>

### uwsgi_buffering

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_buffering` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão                                                                                    | `uwsgi_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 uWSGI.

| `on`   | O Angie recebe uma resposta do servidor uWSGI o mais rápido possível, salvando-a nos buffers definidos pelas diretivas [uwsgi_buffer_size](#uwsgi-buffer-size) e [uwsgi_buffers](#uwsgi-buffers). O envio ao cliente é realizado em paralelo: buffers preenchidos são passados para envio, mas seu tamanho total é limitado por [uwsgi_busy_buffers_size](#uwsgi-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](#uwsgi-temp-path) no disco. A escrita em arquivos temporários é controlada pelas diretivas [uwsgi_max_temp_file_size](#uwsgi-max-temp-file-size) e [uwsgi_temp_file_write_size](#uwsgi-temp-file-write-size).   |
|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | A resposta é passada para o cliente imediatamente conforme é recebida. O Angie trabalha em um loop "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 [uwsgi_buffer_size](#uwsgi-buffer-size). Com `off`, [uwsgi_limit_rate](#uwsgi-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 [uwsgi_ignore_headers](#uwsgi-ignore-headers).

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

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

### uwsgi_buffers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_buffers` number size;   |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão                                                                                    | `uwsgi_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 uWSGI, 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="uwsgi-busy-buffers-size"></a>

### uwsgi_busy_buffers_size

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

Quando o [buffering](#uwsgi-buffering) de respostas do servidor uWSGI 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, fazer buffer de parte da resposta em um arquivo temporário.

Por padrão, o tamanho é limitado pelo tamanho de dois buffers definidos pelas diretivas [uwsgi_buffer_size](#uwsgi-buffer-size) e [uwsgi_buffers](#uwsgi-buffers).

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

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

### uwsgi_cache

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache` zone | `off`;   |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão                                                                                    | `uwsgi_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.

| `off`   | desabilita o cache herdado do nível de configuração anterior.   |
|---------|-----------------------------------------------------------------|

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

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

### uwsgi_cache_background_update

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_background_update` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------|
| Padrão                                                                                    | `uwsgi_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.

#### WARNING
Note que é necessário [permitir](#uwsgi-cache-use-stale-updating) o uso de uma resposta em cache obsoleta quando ela está sendo atualizada.

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

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

### uwsgi_cache_bypass

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_bypass` ...;   |
|-------------------------------------------------------------------------------------------|-----------------------------|
| 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 de string não estiver vazio e não for igual a "0", então a resposta não será obtida do cache:

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

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

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

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

### uwsgi_cache_key

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_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
uwsgi_cache_key localhost:9000$request_uri;
```

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

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

### uwsgi_cache_lock

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_lock` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|------------------------------------|
| Padrão                                                                                    | `uwsgi_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 [uwsgi_cache_key](#uwsgi-cache-key) passando uma requisição para um servidor uWSGI. 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 [uwsgi_cache_lock_timeout](#uwsgi-cache-lock-timeout).

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

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

### uwsgi_cache_lock_age

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

Se a última requisição passada para o servidor uWSGI para popular um novo elemento de cache não foi completada pelo tempo especificado, mais uma requisição pode ser passada para o servidor uWSGI.

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

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

### uwsgi_cache_lock_timeout

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

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

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

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

### uwsgi_cache_max_range_offset

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_max_range_offset` number;   |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| 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 intervalo de bytes. Se o intervalo estiver além do deslocamento, a requisição de intervalo será passada para o servidor uWSGI e a resposta não será armazenada em cache.

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

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

### uwsgi_cache_methods

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_methods` `GET` | `HEAD` | `POST` ...;   |
|-------------------------------------------------------------------------------------------|------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_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 [uwsgi_no_cache](#uwsgi-no-cache).

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

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

### uwsgi_cache_min_uses

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_min_uses` number;   |
|-------------------------------------------------------------------------------------------|----------------------------------|
| Padrão                                                                                    | `uwsgi_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
Os metadados do cache são armazenados em memória compartilhada. Deletar manualmente arquivos de cache não
redefine os contadores e pode levar a comportamento imprevisível. Para
redefinir completamente o cache, pare o servidor, delete 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 deletam
arquivos mas não redefinem o contador uwsgi_cache_min_uses. A diretiva
é destinada a proteger o cache de poluição por requisições infrequentes, e redefinir
o contador na limpeza poderia impactar negativamente o desempenho.

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

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

### uwsgi_cache_path

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_path` path [`levels=`levels] [`use_temp_path=``on` | `off`] `keys_zone=`name:size [`inactive=`time] [`max_size=`size] [`min_free=`size] [`manager_files=`number] [`manager_sleep=`time] [`manager_threshold=`time] [`loader_files=`number] [`loader_sleep=`time] [`loader_threshold=`time];   |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | —                                                                                                                                                                                                                                                                                                          |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http                                                                                                                                                                                                                                                                                                       |

Define o caminho e outros parâmetros de um cache. Os dados do cache são armazenados em arquivos. O nome do arquivo em um cache é resultado da aplicação da função MD5 à [chave de cache](#uwsgi-cache-key).

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

```nginx
uwsgi_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. Porém, esteja ciente de que neste caso um arquivo é copiado entre dois sistemas de arquivos ao invés 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.

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

| `on`   | Se este parâmetro for omitido ou definido para o valor on, o diretório definido pela diretiva [uwsgi_temp_path](#uwsgi-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. Os 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 para 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, e quando o tamanho é excedido ou não há espaço livre suficiente, ele remove os dados usados menos recentemente. Os dados são removidos em iterações.

| `max_size`          | valor limite máximo para tamanho do cache                                               |
|---------------------|-----------------------------------------------------------------------------------------|
| `min_free`          | valor limite mínimo para espaço livre no sistema de arquivos com cache                  |
| `manager_files`     | número máximo de itens de cache deletados em uma iteração<br/><br/>Padrão: `100`        |
| `manager_threshold` | limita o tempo de uma iteração<br/><br/>Padrão: `200` milissegundos                     |
| `manager_sleep`     | tempo pelo qual uma pausa é mantida entre iterações<br/><br/>Padrão: `50` milissegundos |

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

| `loader_files`     | número máximo de itens de cache para 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="uwsgi-cache-revalidate"></a>

### uwsgi_cache_revalidate

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_revalidate` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão                                                                                    | `uwsgi_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="uwsgi-cache-use-stale"></a>

### uwsgi_cache_use_stale

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_use_stale` `error` | `timeout` | `invalid_header` | `updating` | `http_500` | `http_503` |  `http_403` | `http_404` | `http_429` | `off` ...;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_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. Os parâmetros da diretiva correspondem aos parâmetros da diretiva [uwsgi_next_upstream](#uwsgi-next-upstream).

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

O uso de uma resposta em cache obsoleta também pode ser habilitado 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 que definir os parâmetros da diretiva.

Para minimizar o número de requisições aos servidores uwsgi ao popular um novo elemento de cache, a diretiva [uwsgi_cache_lock](#uwsgi-cache-lock) pode ser usada.

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

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

### uwsgi_cache_valid

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_cache_valid` [code ...] time;   |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| 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
uwsgi_cache_valid 200 302 10m;
uwsgi_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
uwsgi_cache_valid 5m;
```

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

Além disso, quaisquer respostas podem ser armazenadas em cache usando o parâmetro `any`:

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

#### NOTE
Os parâmetros de cache também podem ser definidos diretamente no cabeçalho de resposta. Este método tem prioridade maior que definir o 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 0 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`, os parâmetros de cache são determinados pelos campos de cabeçalho `Expires` ou `Cache-Control`.
* Uma resposta com o campo de cabeçalho `Set-Cookie` não será armazenada em cache.
* Uma resposta com o campo de cabeçalho `Vary` com o valor especial "\*" não será armazenada em cache. Uma resposta com o campo de cabeçalho `Vary` com outro valor 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 pode ser desabilitado usando a diretiva [uwsgi_ignore_headers](#uwsgi-ignore-headers).

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

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

### uwsgi_connect_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_connect_timeout` time;   |
|-------------------------------------------------------------------------------------------|---------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi. Deve-se notar que este timeout geralmente não pode exceder 75 segundos.

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

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

### uwsgi_connection_drop

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

Configura o encerramento de todas as conexões com o servidor proxy se ele foi removido do grupo ou marcado como permanentemente indisponível como resultado de um processo de [reresolve](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#reresolve) ou 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 time 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-21"></a>

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

### uwsgi_force_ranges

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

Habilita o suporte a byte-range tanto para respostas em cache quanto não armazenadas em cache de um servidor uwsgi, independentemente da presença do campo `Accept-Ranges` nessas respostas.

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

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

### uwsgi_hide_header

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_hide_header` field;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| 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 `Date`, `Server`, `X-Pad` e `X-Accel-...` da resposta de um servidor uwsgi para um cliente. A diretiva uwsgi_hide_header define campos adicionais que não serão passados. Se, ao contrário, a passagem de campos precisar ser permitida, a diretiva [uwsgi_pass_header](#uwsgi-pass-header) pode ser usada.

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

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

### uwsgi_ignore_client_abort

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_ignore_client_abort` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi deve ser fechada quando um cliente fecha a conexão sem aguardar uma resposta.

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

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

### uwsgi_ignore_headers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_ignore_headers` field ...;   |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| 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 uwsgi. 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 de [cache](#uwsgi-cache-valid) de resposta;
* `X-Accel-Redirect` executa um [redirecionamento interno](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#internal) para a URI especificada;
* `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](#uwsgi-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-25"></a>

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

### uwsgi_intercept_errors

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

Determina se as respostas do servidor uwsgi 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-26"></a>

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

### uwsgi_limit_rate

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_limit_rate` rate;   |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi.
A rate é 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 uwsgi, a taxa geral será duas vezes maior que o limite especificado. A limitação funciona apenas se o [buffering](#uwsgi-buffering) de respostas do servidor uwsgi estiver habilitado.

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

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

### uwsgi_max_temp_file_size

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

Quando o [buffering](#uwsgi-buffering) de respostas do servidor uwsgi está habilitado, e toda a resposta não cabe nos buffers definidos pelas diretivas [uwsgi_buffer_size](#uwsgi-buffer-size) e [uwsgi_buffers](#uwsgi-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 [uwsgi_temp_file_write_size](#uwsgi-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](#uwsgi-cache) ou [armazenadas em disco](#uwsgi-store).

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

<a id="uwsgi-modifier1"></a>

### uwsgi_modifier1

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

Define o valor do campo modifier1 no cabeçalho do pacote uwsgi.

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

<a id="uwsgi-modifier2"></a>

### uwsgi_modifier2

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

Define o valor do campo modifier2 no cabeçalho do pacote uwsgi.

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

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

### uwsgi_next_upstream

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_next_upstream` `error` | `timeout` | `invalid_header` | `http_500` | `http_503` | `http_403` | `http_404` | `http_429` | `non_idempotent` | `off` ...;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_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 no grupo [upstream](https://pt.angie.software//angie/docs/configuration/modules/http/http_upstream.md#http-upstream):

| `error`          | ocorreu um erro de conexão, erro de transmissão de requisição, ou erro de leitura de cabeçalho de resposta;                                                                                                                                                                                                                        |
|------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `timeout`        | ocorreu um timeout durante o estabelecimento de conexão, transmissão de requisição, ou leitura de cabeçalho de resposta;                                                                                                                                                                                                           |
| `invalid_header` | o servidor retornou uma resposta vazia ou inválida;                                                                                                                                                                                                                                                                                |
| `http_500`       | o servidor retornou uma resposta com código 500;                                                                                                                                                                                                                                                                                   |
| `http_503`       | o servidor retornou uma resposta com código 503;                                                                                                                                                                                                                                                                                   |
| `http_403`       | o servidor retornou uma resposta com código 403;                                                                                                                                                                                                                                                                                   |
| `http_404`       | o servidor retornou uma resposta com código 404;                                                                                                                                                                                                                                                                                   |
| `http_429`       | o servidor retornou uma resposta com código 429;                                                                                                                                                                                                                                                                                   |
| `non_idempotent` | normalmente, requisições com métodos [não-idempotentes](https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.2) (`POST`, `LOCK`, `PATCH`) não são passadas para outro servidor se uma requisição para um servidor upstream já foi enviada; habilitar este parâmetro permite explicitamente tentar novamente tais requisições; |
| `off`            | desabilita passar uma requisição para o próximo servidor.                                                                                                                                                                                                                                                                          |

#### NOTE
Deve-se entender que passar uma requisição para o próximo servidor só é possível se nada foi enviado para o cliente ainda. Ou seja, se um erro ou timeout ocorre no meio da transmissão 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`   | são sempre consideradas tentativas mal-sucedidas, mesmo se não estão especificadas na diretiva   |
|--------------------------------------------------------|--------------------------------------------------------------------------------------------------|
| `http_500`<br/><br/>`http_503`<br/><br/>`http_429`     | são consideradas tentativas mal-sucedidas apenas se estão especificadas na diretiva              |
| `http_403`<br/><br/>`http_404`                         | nunca são consideradas tentativas mal-sucedidas                                                  |

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

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

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

### uwsgi_next_upstream_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_next_upstream_timeout` time;   |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão                                                                                    | `uwsgi_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](#uwsgi-next-upstream) servidor.

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

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

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

### uwsgi_next_upstream_tries

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_next_upstream_tries` number;   |
|-------------------------------------------------------------------------------------------|---------------------------------------|
| Padrão                                                                                    | `uwsgi_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](#uwsgi-next-upstream) servidor.

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

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

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

### uwsgi_no_cache

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_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 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
uwsgi_no_cache $cookie_nocache $arg_nocache$arg_comment;
uwsgi_no_cache $http_pragma    $http_authorization;
```

Pode ser usado junto com a diretiva [uwsgi_cache_bypass](#uwsgi-cache-bypass).

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

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

### uwsgi_param

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_param` parameter value [`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 uwsgi. 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 houver diretivas `uwsgi_param` definidas no nível atual.

[Variáveis de ambiente CGI](https://datatracker.ietf.org/doc/html/rfc3875#section-4.1) padrão devem ser fornecidas como cabeçalhos uwsgi, veja o arquivo `uwsgi_params` fornecido na distribuição:

```nginx
location / {
    include uwsgi_params;
#    ...
}
```

No arquivo `uwsgi_params` padrão, `REQUEST_METHOD` é definido como
`$upstream_request_method`.

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
uwsgi_param HTTPS $https if_not_empty;
```

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

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

### uwsgi_pass

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

Define o protocolo e endereço de um servidor uwsgi. Como protocolo, `uwsgi` ou `suwsgi` (uwsgi seguro, uwsgi sobre SSL) podem ser especificados. O endereço pode ser especificado como um nome de domínio ou endereço IP, e uma porta:

```nginx
uwsgi_pass localhost:9000;
uwsgi_pass uwsgi://localhost:9000;
uwsgi_pass suwsgi://[2001:db8::1]:9090;
```

ou como um caminho de socket de domínio UNIX especificado após a palavra `unix` e entre dois-pontos:

```nginx
uwsgi_pass unix:/tmp/uwsgi.socket;
```

Se um nome de domínio resolver para vários endereços, todos eles serão usados em um esquema 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).

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

#### NOTE
Se `uwsgi_pass` for especificado em um `location` com uma barra final no prefixo
(por exemplo, `location /name/`),
e a diretiva [auto_redirect](https://pt.angie.software//angie/docs/configuration/modules/http/index.md#auto-redirect) estiver definida como `default`,
requisições sem uma barra final serão redirecionadas (`/name -> /name/`).

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

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

### uwsgi_pass_header

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

Permite passar campos de cabeçalho [normalmente desabilitados](#uwsgi-hide-header) de um servidor uwsgi para um cliente.

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

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

### uwsgi_pass_request_body

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_pass_request_body` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi. Veja também a diretiva [uwsgi_pass_request_headers](#uwsgi-pass-request-headers).

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

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

### uwsgi_pass_request_headers

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

Habilita ou desabilita a passagem de campos de cabeçalho da requisição original para o servidor uwsgi. Veja também a diretiva [uwsgi_pass_request_body](#uwsgi-pass-request-body).

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

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

### uwsgi_read_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_read_timeout` time;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi. O timeout é definido apenas entre duas operações de leitura sucessivas, não para a transmissão de toda a resposta. Se o servidor uwsgi não transmitir nada dentro deste tempo, a conexão é fechada.

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

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

### uwsgi_request_buffering

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

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

| `on`   | O corpo da requisição é completamente [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 o servidor uwsgi.                               |
|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `off`  | O corpo da requisição é enviado para o servidor uwsgi imediatamente conforme é recebido. Neste caso, a requisição não pode ser passada para o [próximo servidor](#uwsgi-next-upstream) se o Angie já começou a enviar o corpo da requisição. |

Quando a codificação de transferência HTTP/1.1 chunked é usada para enviar o corpo da requisição original, então o corpo da requisição será armazenado em buffer independentemente do valor da diretiva.

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

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

### uwsgi_send_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_send_timeout` time;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi. 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 uwsgi não receber nada dentro deste tempo, a conexão é fechada.

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

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

### uwsgi_socket_keepalive

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_socket_keepalive` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|------------------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi.

| `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-43"></a>

<a id="uwsgi-ssl-certificate"></a>

### uwsgi_ssl_certificate

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

Especifica um arquivo com o certificado no formato PEM usado para autenticação em um servidor uwsgi seguro. Variáveis podem ser usadas no nome do arquivo.

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

<a id="uwsgi-ssl-certificate-cache"></a>

### uwsgi_ssl_certificate_cache

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_ssl_certificate_cache` `off`;<br/><br/>`uwsgi_ssl_certificate_cache` `max=`N [`inactive=`time] [`valid=`time];   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_ssl_certificate_cache off;`                                                                                      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                                                  |

Define um cache que armazena [certificados SSL](#uwsgi-ssl-certificate) e [chaves secretas](#uwsgi-ssl-certificate-key) especificados usando variáveis.

A diretiva suporta os seguintes parâmetros:

- `max` — define o número máximo de elementos no cache. Quando o cache
  transborda, os elementos menos recentemente usados (LRU) são removidos.
- `inactive` — define o tempo após o qual um elemento é removido se não
  foi acessado. O padrão é 10 segundos.
- `valid` — define o tempo durante o qual um elemento em cache é considerado
  válido e pode ser reutilizado. O padrão é 60 segundos. Após este período,
  os certificados são recarregados ou revalidados.
- `off` — desabilita o cache.

Exemplo:

```nginx
uwsgi_ssl_certificate       $uwsgi_ssl_server_name.crt;
uwsgi_ssl_certificate_key   $uwsgi_ssl_server_name.key;
uwsgi_ssl_certificate_cache max=1000 inactive=20s valid=1m;
```

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

<a id="uwsgi-ssl-certificate-key"></a>

### uwsgi_ssl_certificate_key

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

Especifica um arquivo com a chave secreta no formato PEM usado para autenticação em um servidor uwsgi seguro.

O valor `engine:`name`:id` pode ser especificado em vez do arquivo, que carrega uma chave secreta com um id especificado do mecanismo OpenSSL name.

O valor `store:scheme:id` pode ser especificado em vez do arquivo, que é usado para carregar uma chave secreta com um id especificado e esquema de URI registrado no provedor OpenSSL, como [pkcs11](https://datatracker.ietf.org/doc/html/rfc7512).

Variáveis podem ser usadas no nome do arquivo.

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

<a id="uwsgi-ssl-ciphers"></a>

### uwsgi_ssl_ciphers

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

Especifica as cifras habilitadas para requisições a um servidor uwsgi seguro. As cifras são especificadas no formato compreendido pela biblioteca OpenSSL.

A lista de cifras depende da versão do OpenSSL instalada.
A lista completa pode ser visualizada usando o comando `openssl ciphers`.

#### WARNING
A diretiva `uwsgi_ssl_ciphers` *não* configura cifras para TLS
1.3 ao usar OpenSSL. Para ajustar cifras TLS 1.3 com OpenSSL, use a
diretiva [uwsgi_ssl_conf_command](#uwsgi-ssl-conf-command), que foi adicionada para suportar
configuração SSL avançada.

- No LibreSSL, cifras TLS 1.3 *podem* ser configuradas usando
  `uwsgi_ssl_ciphers`.
- No BoringSSL, cifras TLS 1.3 não podem ser configuradas de forma alguma.

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

<a id="uwsgi-ssl-conf-command"></a>

### uwsgi_ssl_conf_command

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

Define [comandos](https://docs.openssl.org/master/man3/SSL_CONF_cmd/) de configuração OpenSSL arbitrários ao estabelecer uma conexão com um servidor uwsgi seguro.

#### NOTE
A diretiva é suportada ao usar OpenSSL 1.0.2 ou superior.
Para configurar cifras TLS 1.3 no OpenSSL, use o comando `ciphersuites`.

Múltiplas diretivas uwsgi_ssl_conf_command podem ser especificadas no mesmo nível. Essas diretivas são herdadas do nível de configuração anterior se e somente se não há diretivas uwsgi_ssl_conf_command definidas no nível atual.

#### WARNING
Note que reconfigurar o OpenSSL diretamente pode resultar em comportamento inesperado.

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

<a id="uwsgi-ssl-crl"></a>

### uwsgi_ssl_crl

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

Especifica um arquivo com certificados revogados (CRL) no formato PEM usado para [verificar](#uwsgi-ssl-verify) o certificado do servidor uwsgi seguro.

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

<a id="uwsgi-ssl-name"></a>

### uwsgi_ssl_name

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_ssl_name` name;                          |
|-------------------------------------------------------------------------------------------|-------------------------------------------------|
| Padrão                                                                                    | `uwsgi_ssl_name `nome do host de uwsgi_pass`;\` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                          |

Permite sobrescrever o nome do servidor usado para [verificar](#uwsgi-ssl-verify) o certificado do servidor uwsgi seguro e para ser [passado através de SNI](#uwsgi-ssl-server-name) ao estabelecer uma conexão com o servidor uwsgi seguro.

Por padrão, o nome do host da diretiva [uwsgi_pass](#uwsgi-pass) é usado.

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

<a id="uwsgi-ssl-password-file"></a>

### uwsgi_ssl_password_file

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

Especifica um arquivo com senhas para [chaves secretas](#uwsgi-ssl-certificate-key) onde cada senha é especificada em uma linha separada. As senhas são tentadas em sequência ao carregar a chave.

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

<a id="uwsgi-ssl-protocols"></a>

### uwsgi_ssl_protocols

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_ssl_protocols` [`SSLv2`] [`SSLv3`] [`TLSv1`] [`TLSv1.1`] [`TLSv1.2`] [`TLSv1.3`];   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_ssl_protocols TLSv1.2 TLSv1.3;`                                                     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                                     |

#### Versionchanged
Alterado na versão 1.2.0: Parâmetro `TLSv1.3` adicionado ao conjunto padrão.

Habilita os protocolos especificados para requisições a um servidor uwsgi seguro.

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

<a id="uwsgi-ssl-server-name"></a>

### uwsgi_ssl_server_name

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

Habilita ou desabilita a passagem do nome do servidor
definido pela diretiva [uwsgi_ssl_name](#uwsgi-ssl-name)
através da extensão TLS
[Server Name Indication](http://en.wikipedia.org/wiki/Server_Name_Indication)
(SNI,
[RFC 6066](https://datatracker.ietf.org/doc/html/rfc6066.html))
ao estabelecer uma conexão com o servidor uwsgi seguro.

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

<a id="uwsgi-ssl-session-reuse"></a>

### uwsgi_ssl_session_reuse

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

Determina se as sessões SSL podem ser reutilizadas ao trabalhar com o servidor uwsgi seguro. Se os erros "SSL3_GET_FINISHED:digest check failed" aparecerem nos logs, tente desabilitar a reutilização de sessão.

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

<a id="uwsgi-ssl-trusted-certificate"></a>

### uwsgi_ssl_trusted_certificate

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

Especifica um arquivo com certificados CA confiáveis no formato PEM usado para [verificar](#uwsgi-ssl-verify) o certificado do servidor uwsgi HTTPS.

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

<a id="uwsgi-ssl-verify"></a>

### uwsgi_ssl_verify

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

Habilita ou desabilita a verificação do certificado do servidor uwsgi.

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

<a id="uwsgi-ssl-verify-depth"></a>

### uwsgi_ssl_verify_depth

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

Define a profundidade de verificação na cadeia de certificados do servidor uwsgi.

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

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

### uwsgi_store

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_store` `on` | `off` | string;   |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão                                                                                    | `uwsgi_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                                                                                                                                                                                                           |

O nome do arquivo pode ser definido explicitamente usando a string com variáveis:

```nginx
uwsgi_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 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 tanto os arquivos salvos quanto um diretório contendo arquivos temporários, definido pela diretiva [uwsgi_temp_path](#uwsgi-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;

    uwsgi_pass         backend:9000;
    ...

    uwsgi_store        on;
    uwsgi_store_access user:rw group:rw all:r;
    uwsgi_temp_path    /data/temp;

    alias              /data/www/;
}
```

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

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

### uwsgi_store_access

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_store_access` usuários:permissões ...;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------|
| Padrão                                                                                    | `uwsgi_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
uwsgi_store_access user:rw group:rw all:r;
```

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

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

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

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

### uwsgi_temp_file_write_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_temp_file_write_size` tamanho;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão                                                                                    | `uwsgi_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 uwsgi para arquivos temporários está habilitado. Por padrão, o tamanho é limitado por dois buffers definidos pelas diretivas [uwsgi_buffer_size](#uwsgi-buffer-size) e [uwsgi_buffers](#uwsgi-buffers). O tamanho máximo de um arquivo temporário é definido pela diretiva [uwsgi_max_temp_file_size](#uwsgi-max-temp-file-size).

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

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

### uwsgi_temp_path

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `uwsgi_temp_path` caminho [nível1 [nível2 [nível3]]]\`;                                                                                                                              |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | `uwsgi_temp_path uwsgi_temp;`<br/>(o caminho depende do [parâmetro de compilação](https://pt.angie.software//angie/docs/installation/sourcebuild.md#paths) `--http-uwsgi-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 dados recebidos de servidores uwsgi. 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
uwsgi_temp_path /spool/angie/uwsgi_temp 1 2;
```

um arquivo temporário pode parecer com isto:

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

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