# Deixar o Drupal mais rápido sem quebrar formulário

Guia documental para instalar as duas camadas de cache do núcleo, excluir /user, /admin e as páginas com token de formulário, e conferir com curl e com a aba Rede se o ganho foi real.

> instale ou confirme os módulos Internal Page Cache e Internal Dynamic Page Cache em Administração › Extensões (/admin/modules) e ajuste tempo de vida e agregação em /admin/config/development/performance. Meça com curl: o X-Drupal-Cache da resposta anônima deve passar de MISS para HIT.

João Rizzon · 2026-09-29 · Infraestrutura web

---

O Drupal já vem com cache de página no núcleo. Em muitas instalações ele está ligado e o dono do site nem sabe, em outras alguém desligou durante o desenvolvimento e esqueceu de religar. Antes de contratar CDN, trocar de plano ou instalar meia dúzia de módulos de performance, vale conferir se dois módulos do núcleo estão instalados em **Administração › Extensões** e medir a mesma URL antes e depois.

Um aviso antes de tudo: não temos medição de laboratório própria de Drupal. Este guia é documental e descreve o comportamento padrão dos dois módulos de cache do núcleo, os nomes dos campos do painel e os cabeçalhos de resposta como eles aparecem numa instalação Drupal 8 em diante; a única fonte externa citada aqui é a documentação do módulo LSCache, mais adiante. Confirme os nomes de campo na versão que você roda, porque rótulos e traduções mudam entre releases. O número que importa é o que você vai medir no seu próprio site, com `curl`, nas seções sobre medição. Um site que já entrega a home em poucas dezenas de milissegundos não vai ficar visivelmente melhor com cache de página, e é honesto descobrir isso antes de mexer.

## Internal Page Cache e Internal Dynamic Page Cache: o que cada um guarda

O Drupal 8 em diante traz dois módulos de núcleo com nomes parecidos e funções diferentes. Confundir os dois é a origem de metade das dúvidas sobre "liguei o cache e nada mudou para quem está logado".

**Internal Page Cache** guarda a página HTML inteira, pronta, e só serve visitante anônimo. Requisição sem cookie de sessão, método GET, resposta 200: entra no cache e a próxima pessoa recebe o HTML sem o Drupal montar a página de novo. Se existe cookie de sessão, esse módulo sai do caminho.

**Internal Dynamic Page Cache** atende todo mundo, inclusive quem está logado. Ele não guarda a página inteira como bloco fechado: guarda a página com buracos nos pedaços personalizados (o bloco "Olá, fulano", o carrinho, o token do formulário) e preenche esses buracos a cada requisição. É mais lento que o cache anônimo, porque monta as partes pessoais toda vez, e ainda assim evita remontar tudo.

|  | Internal Page Cache | Internal Dynamic Page Cache |
|---|---|---||
| Quem recebe | Só visitante anônimo | Anônimo e logado |
| O que guarda | Página HTML completa | Página com marcadores para as partes pessoais |
| Custo por requisição | Menor: o Drupal ainda inicializa o PHP, mas devolve o HTML guardado sem montar a página | Maior que o anônimo: reaproveita o corpo guardado e monta só os pedaços pessoais |
| Cabeçalho de resposta | `X-Drupal-Cache` | `X-Drupal-Dynamic-Cache` |
| Valores do cabeçalho | `HIT` ou `MISS` | `HIT`, `MISS` ou `UNCACHEABLE` |

Os dois podem e devem ficar ligados ao mesmo tempo. Eles não competem: o anônimo pega o atalho mais curto, o logado pega o atalho médio.

## O que fazer antes de mexer no cache

Ligar cache não costuma quebrar site, mas desinstalar módulo mexe na configuração e na tabela de cache, e todo procedimento de painel merece um plano de recuperação.

### O que pode dar errado nesta etapa

Baixo, desde que você tenha cópia do banco e do arquivo de configuração. O que pode dar errado: desinstalar um módulo por engano, perder um ajuste manual feito antigamente em `settings.php`, ou descobrir que a hospedagem não deixa você restaurar sozinho.

### Backup do banco e do settings.php em dois comandos

Pelo painel da hospedagem, exporte o banco de dados e baixe uma cópia da pasta do site. Se você tem acesso SSH, dois comandos resolvem:

```bash
mysqldump -u USUARIO -p NOME_DO_BANCO > backup-drupal-antes-cache.sql
cp sites/default/settings.php sites/default/settings.php.bak
```

O primeiro pede a senha e grava o dump no diretório atual. O segundo duplica o arquivo de configuração do Drupal, que é onde ficam credenciais do banco, `$settings['trusted_host_patterns']` e eventuais ajustes de cache feitos à mão. Confira que o `.sql` tem tamanho maior que zero antes de seguir.

### Três degraus para voltar atrás se algo quebrar

Se alguma coisa sair do esperado, o caminho de volta tem três degraus, do mais leve para o mais pesado:

- Limpar todos os caches em **Configuração › Desenvolvimento › Desempenho** (`/admin/config/development/performance`) e recarregar a página em janela anônima.
- Desligar o módulo problemático em **Administração › Extensões › Desinstalar** e limpar os caches de novo.
- Restaurar o dump do banco e o `settings.php.bak`.

Na prática, limpar todos os caches resolve quase tudo relacionado a conteúdo velho aparecendo na tela.

## Ligar as duas camadas pelo painel do Drupal

### Confirmar os dois módulos em /admin/modules

Entre no painel como administrador e vá em **Administração › Extensões** (`/admin/modules`). Use o campo de filtro e digite `cache`. Procure por **Internal Page Cache** e **Internal Dynamic Page Cache**. No perfil padrão de instalação eles vêm marcados. Se algum estiver desmarcado, marque a caixa e clique em **Instalar** no fim da página. É aqui que as duas camadas são ligadas ou desligadas, não na tela de Desempenho.

Se o site foi entregue por uma agência e alguém desmarcou o Internal Page Cache, pergunte por quê antes de religar. Existe caso legítimo: site que mostra conteúdo diferente por região sem declarar os *cache contexts* corretos, ou seja, as regras que mandam o Drupal guardar uma versão separada da página por idioma, país, permissão ou papel do usuário. Sem essas regras, uma versão pode vazar para quem não deveria vê-la. Raro, mas existe.

### Definir a idade máxima do cache de navegador e proxy

Vá em **Configuração › Desenvolvimento › Desempenho** (`/admin/config/development/performance`). O campo **Browser and proxy cache maximum age** (em português, algo como "idade máxima do cache de navegador e proxy") define por quanto tempo navegadores, proxies e CDNs podem reutilizar a resposta sem perguntar ao servidor de novo.

Comece conservador. Para um site institucional que muda poucas vezes por semana, valores de algumas horas são confortáveis. Para um portal de notícias, minutos. O valor **&lt;no caching&gt;** aqui não desliga o cache interno do Drupal, ele apenas impede que o navegador e o proxy guardem a resposta, o que significa que cada visitante volta ao servidor a cada clique.

### Agregar CSS e JavaScript sem quebrar o tema

Na mesma tela existem as caixas **Aggregate CSS files** e **Aggregate JavaScript files**. Marque as duas. Elas juntam dezenas de arquivos pequenos em poucos arquivos maiores, o que reduz o número de requisições. Depois de salvar, abra o site em janela anônima e confira se o layout continua correto e se não há erro de JavaScript no console do navegador. Tema mal escrito às vezes depende da ordem original dos arquivos.

### Salvar a configuração e limpar todos os caches

Clique em **Save configuration** e depois em **Clear all caches**. A limpeza pode demorar alguns segundos e deixar a primeira visita mais lenta, porque tudo é remontado. Isso é esperado.

## Rotas que nunca podem ser cacheadas na camada do servidor

O cache interno do Drupal já sabe se proteger: ele não guarda resposta de requisição com cookie de sessão. O perigo mora na camada de cima, quando você adiciona um cache de página no servidor (LiteSpeed, Varnish, proxy da CDN) que guarda HTML sem entender o que é sessão.

As rotas abaixo precisam entrar na lista de exclusão dessa camada de servidor:

| Caminho | Por quê |
|---|---||
| `/user` e `/user/*` | Login, registro, recuperação de senha e perfil. HTML pessoal e token de formulário. |
| `/admin/*` | Todo o painel. Conteúdo só existe com sessão válida. |
| `/node/*/edit`, `/node/add/*` | Formulários de edição com token. |
| `/system/*`, `/core/*`, `/update.php` | Rotas internas e de manutenção. |
| Qualquer página com formulário que envia dado | Contato, busca com POST, comentário, checkout. |

### Por que o token anti-CSRF derruba o formulário de contato

Todo formulário do Drupal que altera dado carrega um token anti-CSRF dentro do HTML. Esse token é amarrado à sessão de quem pediu a página. Quando um cache de servidor guarda a página inteira com o token da pessoa A e entrega esse mesmo HTML para a pessoa B, o Drupal recebe um envio com token que não bate. O resultado não é uma falha silenciosa: o visitante clica em enviar e recebe a mensagem de formulário desatualizado, pedindo para copiar o texto e recarregar a página. Do ponto de vista do visitante, o site simplesmente não envia o formulário.

O sintoma clássico é o formulário de contato que "funcionava e parou", sem nenhuma alteração no site, logo depois que alguém ligou cache no servidor. A correção é excluir a rota do cache, não reescrever o formulário.

## Medir a mesma URL antes e depois

Escolha uma URL pública que não seja a home, de preferência um artigo ou uma página interna com conteúdo real. A home costuma ter tratamento especial em CDN e dá leitura enviesada.

### Medir o tempo até o primeiro byte com curl

```bash
curl -o /dev/null -s -w '%{time_starttransfer}\n' https://exemplo.com.br/sobre
```

Linha por linha: `-o /dev/null` joga fora o HTML porque só interessa o tempo, `-s` esconde a barra de progresso, e `-w '%{time_starttransfer}'` imprime o tempo em segundos desde o início da requisição até o primeiro byte do corpo da resposta chegar. É o TTFB do ponto de vista de quem chama, e inclui DNS, conexão, TLS e processamento no servidor.

Rode o comando cinco vezes seguidas e anote todos os valores, não só o menor. A primeira execução carrega DNS e handshake e sempre sai mais alta. Faça isso antes de mexer em qualquer coisa e repita depois, na mesma URL, do mesmo lugar, no mesmo horário aproximado, sempre cinco vezes. Comparar medição feita do notebook de casa com medição feita de um servidor em outro país não diz nada sobre o cache.

### Ler o X-Drupal-Cache e a transição de MISS para HIT

```bash
curl -s -D - -o /dev/null https://exemplo.com.br/sobre | grep -i -E 'x-drupal|cache-control|age'
```

O `-D -` manda os cabeçalhos de resposta para a saída padrão, o `-o /dev/null` descarta o corpo, e o `grep -i -E` filtra as linhas que interessam sem diferenciar maiúscula de minúscula.

Exemplo fictício de saída na primeira chamada, para ilustrar o formato:

```
cache-control: max-age=3600, public
x-drupal-cache: MISS
x-drupal-dynamic-cache: MISS
```

Exemplo fictício da segunda chamada, com o cache já quente:

```
cache-control: max-age=3600, public
x-drupal-cache: HIT
x-drupal-dynamic-cache: HIT
```

Esses valores são ilustrativos, não são medição nossa. O que você precisa observar no seu site é a transição: `MISS` na primeira chamada de uma URL nova, `HIT` na segunda. Se o `X-Drupal-Cache` nunca vira `HIT`, o Internal Page Cache não está atuando naquela rota. Se o cabeçalho não aparece de jeito nenhum, três hipóteses, nesta ordem: o módulo está desinstalado, você está enviando cookie de sessão na requisição (teste em aba anônima ou com `curl` puro, que não manda cookie), ou existe um proxy na frente removendo cabeçalhos.

Um `X-Drupal-Dynamic-Cache: UNCACHEABLE` não é erro. Esse valor indica que a resposta tem algo que o Drupal decidiu não guardar, normalmente uma mensagem de sessão ou um bloco sem metadados de cache declarados.

### Conferir a camada logada no navegador com F12

O `curl` do exemplo não envia cookie de sessão. Por isso ele valida apenas a camada anônima: o `X-Drupal-Cache` indo de `MISS` para `HIT` diz que o Internal Page Cache está funcionando para visitante deslogado, e não diz nada sobre o que acontece com quem tem sessão.

Para conferir o `X-Drupal-Dynamic-Cache` com sessão ativa, use o navegador:

- Faça login no site normalmente.
- Abra as ferramentas de desenvolvedor com **F12** e vá na aba **Rede** (**Network** em inglês).
- Recarregue a página que você quer testar e clique na primeira linha da lista, a que tem o mesmo endereço da página (tipo `document`).
- No painel da direita, procure **Cabeçalhos de resposta** (**Response Headers**) e a linha `x-drupal-dynamic-cache`.
- Recarregue uma segunda vez e olhe de novo. O esperado é `MISS` na primeira carga e `HIT` na segunda.

Se aparecer `UNCACHEABLE` sempre, é sinal de que aquela página logada tem algum bloco sem metadados de cache. Se o cabeçalho não aparecer, confira o passo 1 do painel: o Internal Dynamic Page Cache pode estar desinstalado.

## Quando o purge para no meio entre Drupal e servidor

A combinação cache do Drupal mais cache do servidor funciona bem quando os dois sabem um do outro. Funciona mal quando são ligados por pessoas diferentes em momentos diferentes.

O problema típico é o *purge* pela metade. Purge é o ato de apagar a cópia guardada na camada do servidor, e ele é diferente de limpar o cache dentro do Drupal. Você edita um artigo, o Drupal invalida a versão guardada daquela página pela *cache tag* dela (a etiqueta que liga a página ao conteúdo exibido e permite descartar só o que mudou, em vez de esvaziar tudo), o HTML interno é descartado corretamente, e mesmo assim o visitante continua vendo a versão velha por horas. Motivo: a camada do servidor guardou uma cópia do HTML antigo e não foi avisada da alteração. Você limpa o cache do Drupal em **Configuração › Desenvolvimento › Desempenho**, nada muda na tela, e a conclusão errada é que "o cache do Drupal está quebrado".

O caminho recomendado é usar um módulo de integração que faça a ponte entre a invalidação do Drupal e o purge no servidor, em vez de deixar as duas camadas cegas uma para a outra. Em hospedagem com LiteSpeed, a integração é o módulo LSCache for Drupal, cuja página de configuração e cujos parâmetros estão descritos na [documentação oficial do LiteSpeed](https://docs.litespeedtech.com/lscache/lscdrupal/settings/). Consulte essa página para os nomes exatos dos campos na versão que você instalou, porque eles mudam entre releases, e confira ali o comportamento de tempo de vida e de exclusões antes de ativar.

Três regras práticas para não sofrer:

- Ligue uma camada de cada vez e meça entre uma e outra. Se ligar as duas no mesmo dia, você não sabe qual delas produziu o resultado nem qual delas quebrou o formulário.
- Repita a lista de exclusões na camada do servidor. O Drupal se protege sozinho, o cache de servidor não adivinha o que é `/user`.
- Depois de publicar um conteúdo, teste com `curl` se a URL alterada mudou de fato. Se o corpo antigo voltar com `HIT`, o purge não atravessou as duas camadas.

## Quatro causas de lentidão que o cache de página não resolve

Cache de página resolve um tipo específico de lentidão: página pública que o servidor monta do zero a cada visita. Ele não resolve os casos abaixo, e insistir nele só adia o diagnóstico.

- **Consulta lenta no banco.** Se a página logada continua pesada mesmo com Dynamic Page Cache ativo, o gargalo é uma view mal filtrada ou uma tabela sem índice. Ative o log de consulta lenta no MySQL ou MariaDB e olhe o que aparece. Isso costuma custar uma tarde de trabalho e zero real de plano novo.
- **Imagem sem otimização.** Foto de 4 MB no corpo do artigo não fica mais leve com cache de página. Confira os estilos de imagem em **Configuração › Mídia › Estilos de imagem** e garanta que o tema entrega os derivados, isto é, as versões redimensionadas que o Drupal gera a partir do original, e não o arquivo original em tamanho cheio.
- **Versão antiga de PHP.** Rodar PHP desatualizado custa desempenho e segurança. Verifique em **Relatórios › Status do site** qual versão está ativa e se o OPcache está habilitado.
- **Excesso de módulos contribuídos.** Cada módulo instalado carrega código a cada requisição. Módulo que ninguém usa há um ano é candidato a desinstalação, com backup antes.

Se o TTFB medido com `curl` já estava baixo antes de ligar o cache e continuou igual depois, aceite o resultado: aquela página não era o problema. Procure a página lenta de verdade, medindo uma a uma, em vez de trocar de plano por precaução.

## Checklist na ordem de execução

- Backup do banco e cópia do `sites/default/settings.php`.
- Medir o TTFB da URL escolhida com `curl`, cinco vezes, anotando todos os valores.
- Confirmar **Internal Page Cache** e **Internal Dynamic Page Cache** instalados em `/admin/modules`.
- Ajustar a idade máxima do cache e marcar a agregação de CSS e JavaScript em `/admin/config/development/performance`.
- Salvar, limpar todos os caches e conferir o site em janela anônima.
- Medir de novo a mesma URL, cinco vezes, e checar o `X-Drupal-Cache` da resposta anônima indo de `MISS` para `HIT` (o `curl` do exemplo não manda cookie, então essa checagem cobre só a camada anônima).
- Logado, abrir a mesma página com **F12 › Rede**, clicar na requisição do documento e conferir o `x-drupal-dynamic-cache` passando de `MISS` para `HIT` na segunda carga.
- Testar, logado e deslogado, o login, um formulário de contato e a edição de um conteúdo.
- Só então, se for o caso, ligar o cache do servidor com as exclusões de `/user`, `/admin` e rotas de formulário.

Se o teste de formulários falhar com mensagem de formulário desatualizado, o problema está na camada de cache do servidor, não no Drupal. Volte para a lista de exclusões antes de qualquer outra coisa.

