# Aumentar o limite de upload do WordPress em VPS sem cPanel

O erro em português vem do PHP. O erro 413 vem do servidor web. São arquivos diferentes, serviços diferentes e recarregamentos diferentes.

> em VPS sem painel, você ajusta dois limites independentes: `upload_max_filesize` e `post_max_size` no php.ini (erro em português dentro do WordPress) e `client_max_body_size` no Nginx ou `LimitRequestBody` no Apache (erro 413). Depois, reinicie cada serviço e refaça o upload.

João Rizzon · 2026-10-28 · Servidores

---

Subir um arquivo de 40 MB na Biblioteca de Mídia e receber "excede o tamanho máximo de upload para este site" é um problema. Subir o mesmo arquivo e receber uma página branca com **413 Request Entity Too Large** é outro problema, com outro culpado e outro arquivo de configuração. Em VPS criada a partir de imagem de nuvem (a imagem WordPress da DigitalOcean, da Vultr, da Hetzner, ou uma instalação sua com LAMP/LEMP), não existe a tela "MultiPHP INI Editor" do cPanel para resolver os dois de uma vez. Você edita arquivo e reinicia serviço.

Este guia é documental: os caminhos de arquivo e os nomes de diretiva vêm da documentação dos projetos e da [documentação oficial da LiteSpeed sobre otimizar upload no WordPress](https://docs.litespeedtech.com/shared/cloud/OPT-WPUPLOAD/). Todos os valores numéricos que aparecem aqui são **exemplos**, não recomendação universal nem medição nossa.

## Os dois tetos, e por que o segundo quase nunca aparece em tutorial

Um upload de mídia no WordPress atravessa duas camadas que podem recusar o arquivo antes de ele chegar ao destino:

| Camada | Diretivas | Como o erro aparece | O WordPress mostra o limite? |
|---|---|---|---||
| PHP | `upload_max_filesize`, `post_max_size`, `memory_limit`, `max_input_time` | Mensagem do próprio WordPress, em português, dentro do painel | Sim, o número aparece em Mídia > Adicionar |
| Servidor web | `client_max_body_size` (Nginx), `LimitRequestBody` (Apache), Max Request Body Size (LiteSpeed/OpenLiteSpeed, em Tuning) | Erro 413, página do servidor, sem tradução | Não, o WordPress nem é chamado |

A ordem importa. O servidor web lê os cabeçalhos da requisição primeiro. Se o corpo passa do limite dele, ele corta a conexão e devolve 413 sem repassar nada ao PHP. Por isso o teto do servidor web é invisível na tela "Tamanho máximo de upload do arquivo: 2 MB": aquele número vem do PHP, só do PHP.

O contrário também acontece. Você sobe `client_max_body_size` para 128M, tenta de novo e volta a mensagem do WordPress dizendo 2 MB. Nesse caso quem barrou foi o PHP, e você mexeu no arquivo errado.

## Descobrir qual dos dois barrou antes de editar qualquer coisa

### Mensagem em português é PHP, 413 é servidor web

Mensagem em português, dentro do admin, citando um tamanho: **PHP**. Tela crua do servidor com "413 Request Entity Too Large" ou "Request Entity Too Large": **servidor web**. Tela branca ou erro de rede no uploader ao arrastar o arquivo: abra o DevTools do navegador (F12), aba Rede, repita o upload e olhe o código de status da chamada para `admin-ajax.php` ou `async-upload.php`. Status 413 confirma o servidor web.

### Ver quais valores o PHP está publicando neste momento

Sem painel, o jeito mais confiável de ler os valores em vigor é o `php -i` do mesmo binário que serve o site:

```
php -i | grep -E "upload_max_filesize|post_max_size|memory_limit|Loaded Configuration File"
```

Saída esperada, algo no formato:

```
Loaded Configuration File => /etc/php/8.2/fpm/php.ini
memory_limit => 256M => 256M
post_max_size => 8M => 8M
upload_max_filesize => 2M => 2M
```

A linha **Loaded Configuration File** é o ouro aqui: é o arquivo que você precisa editar, informado pelo próprio PHP, sem adivinhação.

Uma ressalva: em muitas imagens de nuvem a CLI usa um `php.ini` diferente do PHP-FPM que atende o site. Se a saída mostrar `/etc/php/8.2/cli/php.ini`, troque `cli` por `fpm` no caminho. Para confirmar pelo lado do site, crie temporariamente um `info.php` na raiz com `<?php phpinfo();`, abra no navegador, anote os valores e **apague o arquivo em seguida**: ele expõe caminhos e módulos do servidor.

### Descobrir qual servidor web responde pelo site

```
curl -sI https://seudominio.com.br | grep -i "^server:"
```

Retorna `Server: nginx`, `Server: Apache` ou `Server: LiteSpeed`. Se houver Cloudflare na frente, o cabeçalho vem como `cloudflare` e você precisa olhar direto no servidor: `systemctl status nginx apache2 lshttpd` mostra qual está ativo.

## Backup e plano de volta antes de tocar em qualquer arquivo

Todo arquivo tocado aqui derruba o serviço se ficar com erro de sintaxe. O risco real é o site sair do ar, não a perda de dados. Copie antes de editar:

```
sudo cp /etc/php/8.2/fpm/php.ini /etc/php/8.2/fpm/php.ini.bak
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak
```

Para voltar atrás, copie o `.bak` por cima do original e reinicie o serviço. Mantenha uma segunda sessão SSH aberta durante o procedimento: se a primeira travar, você ainda tem acesso para restaurar.

Se o site é de produção e você nunca fez isso, tire um snapshot da VPS no painel do provedor. Leva poucos minutos e cobre qualquer engano.

## Ajustar o teto do PHP no php.ini

Abra o arquivo que o `Loaded Configuration File` apontou:

```
sudo nano /etc/php/8.2/fpm/php.ini
```

No nano, use `Ctrl+W` para buscar cada diretiva. Valores de **exemplo**, para um site que precisa aceitar arquivos de até 64 MB:

```
upload_max_filesize = 64M
post_max_size = 128M
memory_limit = 256M
max_execution_time = 300
max_input_time = 300
```

Três regras que evitam o erro clássico de mexer em uma diretiva só:

- `post_max_size` precisa ser **maior** que `upload_max_filesize`. O POST carrega o arquivo mais os campos do formulário. A documentação da LiteSpeed sobre upload no WordPress trata as duas diretivas em conjunto justamente por isso.
- `memory_limit` igual ou maior que `post_max_size`, principalmente se o site gera miniaturas de imagens grandes.
- `max_input_time` é o que importa em link lento: ele limita o tempo de recebimento do corpo da requisição, e um arquivo de 64 MB subindo a 2 Mbps leva mais de quatro minutos. O `max_execution_time` cobre outra fase, o processamento depois que o arquivo já chegou (geração de miniaturas de uma imagem grande, por exemplo). Mexer só em um dos dois deixa metade do caminho sem folga.

Salve com `Ctrl+O`, `Enter`, e saia com `Ctrl+X`. Agora recarregue o PHP-FPM:

```
sudo systemctl reload php8.2-fpm
```

Ajuste `8.2` para a sua versão. Confirme que o serviço continua de pé:

```
systemctl is-active php8.2-fpm
```

A resposta esperada é `active`. Se vier `failed`, rode `sudo systemctl status php8.2-fpm` e leia a última linha: ela costuma apontar a linha exata do `php.ini` com problema.

### Onde cada stack guarda o php.ini que atende o site

| Stack | Caminho típico do php.ini do site | Comando de recarga |
|---|---|---||
| Nginx + PHP-FPM (Debian/Ubuntu) | `/etc/php/8.X/fpm/php.ini` | `sudo systemctl reload php8.X-fpm` |
| Nginx + PHP-FPM (CentOS/Alma/Rocky) | `/etc/php.ini` | `sudo systemctl reload php-fpm` |
| Apache com mod_php | `/etc/php/8.X/apache2/php.ini` | `sudo systemctl reload apache2` |
| OpenLiteSpeed | `/usr/local/lsws/lsphp8X/etc/php/8.X/litespeed/php.ini` | `sudo systemctl restart lshttpd` |

Em Apache com mod_php, mudar o `php.ini` exige recarregar o **Apache**, não um serviço de PHP separado. Em OpenLiteSpeed, o PHP roda sob o processo do servidor, então o restart é do `lshttpd`.

## Ajustar o teto do servidor web, que é quem devolve 413

### Nginx, client_max_body_size e em qual bloco colocar

Edite `/etc/nginx/nginx.conf` e, dentro do bloco `http { ... }`, acrescente ou ajuste (valor de **exemplo**, alinhado ao `post_max_size` escolhido acima):

```
client_max_body_size 128M;
```

Colocar no bloco `http` vale para todos os sites da máquina. Se você prefere restringir a um site, a mesma linha funciona dentro do `server { }` do arquivo em `/etc/nginx/sites-available/` ou `/etc/nginx/conf.d/`. A diretiva mais específica vence.

Teste a sintaxe antes de recarregar, sempre:

```
sudo nginx -t
```

Saída esperada: `syntax is ok` seguido de `test is successful`. Só então:

```
sudo systemctl reload nginx
```

Se o `nginx -t` acusar erro, nada foi aplicado e o site continua no ar: corrija o arquivo e teste de novo.

### Apache, LimitRequestBody e o valor em bytes

No virtual host do site (em `/etc/apache2/sites-available/` ou `/etc/httpd/conf.d/`), dentro do bloco `<VirtualHost>` ou de um `<Directory>`:

```
LimitRequestBody 134217728
```

O Apache espera o valor em **bytes**, não em `M`. O exemplo acima equivale a 128 MB. O valor `0` significa sem limite, o que não é boa ideia em servidor exposto. Teste e recarregue:

```
sudo apachectl configtest
sudo systemctl reload apache2
```

A resposta esperada do `configtest` é `Syntax OK`.

### LiteSpeed e OpenLiteSpeed, ajuste em Tuning com graceful restart

O ajuste fica no painel administrativo (porta 7080 no OpenLiteSpeed), em Server Configuration > Tuning, no campo de tamanho máximo do corpo da requisição, e exige **Graceful Restart** para valer. A documentação da LiteSpeed para upload no WordPress orienta tratar os limites do PHP junto com os do servidor, pelo mesmo motivo descrito aqui: ajustar um e esquecer o outro não resolve.

### Quando o 413 nasce no proxy reverso ou na CDN

Se existe um segundo Nginx como proxy reverso, ou um balanceador, ele tem o próprio `client_max_body_size` e o 413 pode nascer ali, antes de chegar à sua VPS. No caso do Cloudflare, existe um limite de tamanho de corpo por requisição que varia conforme o plano e não é editável por você no plano gratuito. Teste apontando o `/etc/hosts` da sua máquina direto para o IP do servidor: se o upload passa sem a CDN, o teto é da CDN.

## Confirmar refazendo o upload que falhou

Não confie no arquivo de configuração, confie no resultado.

- No painel do WordPress, vá em **Mídia > Adicionar nova**. O texto abaixo da área de arrastar agora deve mostrar o novo valor de `upload_max_filesize`. Se ainda mostra o antigo, o PHP-FPM não foi recarregado ou você editou o `php.ini` do CLI.
- Em **Ferramentas > Saúde do site > Informações > Servidor**, confira `upload_max_filesize`, `post_max_size` e `memory_limit`. Essa tela lê o PHP que de fato atende o site.
- Suba exatamente o arquivo que falhou antes. Mesmo arquivo, mesmo navegador.
- Se voltar 413, o ajuste do servidor web não pegou: reveja em qual bloco a diretiva entrou e se o `reload` rodou sem erro.
- Se voltar a mensagem do WordPress com o tamanho antigo, há um segundo `php.ini` ou um `.user.ini` sobrescrevendo. Procure: `find /var/www -name ".user.ini" -o -name ".htaccess" | head`.

Um detalhe que engana bastante: plugins de segurança e alguns temas definem `upload_max_filesize` via `.user.ini` na raiz do site. Esse arquivo tem precedência sobre o `php.ini` global em PHP-FPM, e o cache dele é de 5 minutos por padrão. Se você editou um `.user.ini`, espere alguns minutos antes de concluir que não funcionou.

## Quando aumentar o limite é a solução errada

Vale dizer contra o hábito: nem todo upload grande deveria passar pelo navegador.

- **Vídeo**: hospedar MP4 pesado na Biblioteca de Mídia consome disco e banda, e o player nativo não entrega o que um serviço de vídeo entrega. YouTube, Vimeo ou um bucket de objetos resolvem melhor.
- **Backup de migração**: arquivos de plugins como All-in-One WP Migration ou Duplicator costumam passar de 1 GB. Enviar por SFTP para `wp-content/ai1wm-backups/` ou para a pasta do plugin evita mexer em limite nenhum, e é mais rápido.
- **Imagem de câmera sem tratamento**: um JPEG de 25 MB vira uma página lenta. Redimensionar antes de subir resolve a causa, não o sintoma.

Limite alto demais também tem custo: cada upload simultâneo reserva memória do PHP, e um `client_max_body_size` generoso aumenta a superfície para abuso em formulários públicos. Se o site precisa aceitar 64 MB em uma única rota de administração, considere aplicar o limite maior só no bloco `location` de `/wp-admin/` no Nginx, e manter o resto do site com um teto menor.

## Checklist para colar no terminal

```
# 1. onde está o php.ini em uso
php -i | grep "Loaded Configuration File"

# 2. valores atuais
php -i | grep -E "upload_max_filesize|post_max_size|memory_limit"

# 3. qual servidor web responde
curl -sI https://seudominio.com.br | grep -i "^server:"

# 4. backup antes de editar
sudo cp /etc/php/8.2/fpm/php.ini /etc/php/8.2/fpm/php.ini.bak
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak

# 5. testar e recarregar
sudo nginx -t && sudo systemctl reload nginx
sudo systemctl reload php8.2-fpm

# 6. conferir que subiu de pé
systemctl is-active nginx php8.2-fpm
```

Se os dois tetos estão coerentes entre si, o PHP recarregado e o servidor web recarregado, o upload que falhava passa. Se não passa, o próximo suspeito está fora da VPS: proxy, CDN ou um `.user.ini` do próprio site.

