# Cache no MediaWiki: wiki rápido sem quebrar quem edita

O cache de página vale para visitante anônimo e só para ele. O resto do ajuste é decidir quais URLs ficam de fora e garantir que a limpeza aconteça na página editada.

> ligar o cache de servidor só para visitante anônimo, excluir as URLs de ação do MediaWiki (edit, submit, history, delete, protect, raw, purge, Special:, api.php, load.php) e configurar a purga para disparar no salvamento da página, nunca no site inteiro.

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

---

Wiki lento quase nunca é falta de CPU. É o MediaWiki remontando a mesma página a cada visita: lê o parser cache, resolve templates, consulta o banco, renderiza o skin e só então entrega HTML. Para um artigo com muitas transclusões, isso é trabalho repetido milhares de vezes por dia para entregar exatamente o mesmo conteúdo ao visitante anônimo.

Cache de servidor resolve isso guardando o HTML pronto e servindo direto. Só que MediaWiki tem duas regras que não aparecem em Joomla, Drupal ou WordPress: o cache só pode valer para quem **não está logado**, e a limpeza precisa acontecer **no salvamento da página editada**, não no site inteiro. Errar qualquer uma das duas produz um wiki que parece rápido e mostra conteúdo errado.

## Por que cachear usuário logado expõe identidade e quebra o token de edição

O HTML que o MediaWiki devolve para um editor logado não é o mesmo que ele devolve para um anônimo. Muda a barra de ferramentas, muda o link "editar", muda o watchlist, mudam as preferências de skin, e muda o token de edição embutido no formulário.

Se um HTML de usuário logado for salvo no cache e servido a outra pessoa, duas coisas acontecem: o segundo visitante vê o nome do primeiro no topo da página, e qualquer tentativa de edição falha com erro de token perdido. É o mesmo mecanismo que quebra carrinho de loja em cache, com o agravante de expor identidade.

Por isso a regra é absoluta: **cache público apenas para requisições sem cookie de sessão do MediaWiki**. Qualquer configuração que não respeite isso precisa ser desligada, não ajustada.

## As URLs de ação que precisam ficar fora do cache

MediaWiki concentra tudo em `index.php` com parâmetros de query. Não existe URL bonita separando leitura de escrita, então a exclusão é por parâmetro e por namespace.

| Caminho ou padrão | Por que fica fora |
|---|---||
| `/index.php?action=edit` | Formulário com token de edição por sessão |
| `/index.php?action=submit` | Gravação, nunca pode ser servida de cache |
| `/index.php?action=history` | Muda a cada revisão salva |
| `/index.php?action=delete` | Ação administrativa |
| `/index.php?action=protect` | Ação administrativa |
| `/index.php?action=raw` | Saída usada por gadgets e scripts |
| `/index.php?action=purge` | É o próprio comando de limpeza |
| `/Special:*` e `/index.php?title=Special:*` | Busca, login, preferências, páginas recentes |
| `/api.php` | API: resposta depende do token e do usuário |
| `/load.php` | ResourceLoader já tem cache próprio por versão |

Se o wiki usa URLs curtas (`/wiki/Nome_do_artigo`), lembre que o `Special:` aparece nos dois formatos: `/wiki/Special:RecentChanges` e `/index.php?title=Special:Search`. Marque os dois.

Namespace de usuário (`/wiki/Usuário:` ou `/wiki/User:`) pode ficar no cache, porque o conteúdo é público e o controle de sessão já cuida do resto. Páginas de discussão também. O corte é por **ação**, não por tipo de página.

## Ligando o cache sem derrubar o wiki com tela branca

Os passos abaixo seguem o comportamento descrito na [documentação do LSCache para MediaWiki](https://docs.litespeedtech.com/lscache/lscmw/settings/). Antes de mexer, faça backup dos arquivos e do banco. Reverter é simples (desligar a opção), mas se você editar o `LocalSettings.php` à mão, uma linha torta derruba o wiki inteiro com tela branca.

### Confirme em Special:Version que a extensão está carregada

Acesse `/wiki/Special:Version` (ou `/index.php?title=Special:Version`). Procure a seção **Extensões instaladas**. A extensão de cache precisa aparecer na lista. Se não aparecer, ela não foi carregada no `LocalSettings.php` e nenhuma configuração de painel terá efeito.

### Onde ficam as variáveis de cache: o LocalSettings.php

MediaWiki não tem tela de configuração de extensão no painel administrativo. Tudo (liga/desliga do cache, TTL, lista de exclusões) é variável no `LocalSettings.php`, o arquivo na raiz da instalação, no mesmo diretório de `index.php` e `api.php`.

Para editar, duas vias: o gerenciador de arquivos do painel de hospedagem (abrir o File Manager, navegar até a pasta do wiki, selecionar `LocalSettings.php`, botão Edit) ou conexão por SFTP, baixando e reenviando o arquivo. Antes de alterar qualquer linha, faça uma cópia no mesmo diretório com o nome `LocalSettings.php.bak`. Se a edição derrubar o wiki com tela branca, você renomeia a cópia de volta e o site volta ao estado anterior.

Os nomes exatos das variáveis de cache, TTL e exclusão estão na página de configurações da extensão, na documentação citada acima. Copie de lá, não de memória: um nome de variável errado é ignorado em silêncio e você fica achando que configurou algo que o MediaWiki nunca leu.

### Cache público ligado, cache por usuário desligado

Ligue a variável de cache público da extensão, a que vale para visitante não autenticado. Não habilite cache privado por usuário, a menos que você entenda exatamente o que está fazendo e tenha testado login simultâneo de duas contas diferentes.

### Que TTL usar enquanto você ainda valida a purga

Para wiki interno com edição frequente, um TTL curto (minutos) é mais seguro enquanto você valida a purga. Depois que confirmar que a limpeza no save funciona, o TTL pode subir bastante, porque a purga passa a ser o mecanismo principal de atualização, não a expiração.

### Colando a lista de exclusões no array

A lista de exclusões é um array no `LocalSettings.php`: uma entrada por item, usando a tabela da seção anterior. Salve o arquivo, recarregue a página inicial do wiki no navegador para confirmar que ele subiu sem tela branca e abra uma página de edição para conferir que ela não ficou presa.

## Purga da página editada, nunca do site inteiro

O erro mais comum é configurar "limpar todo o cache ao publicar". Em wiki com dezenas de milhares de páginas, isso joga fora o cache inteiro porque alguém corrigiu uma vírgula. O servidor volta a renderizar tudo do zero e o wiki fica mais lento logo depois de cada edição.

O comportamento correto é a purga seletiva: ao salvar, invalidar a URL da página editada e as URLs que dependem dela. Existem dois caminhos para isso, e você escolhe um. O primeiro é a purga nativa da extensão, que avisa o cache do próprio servidor quando uma página é salva: é o caminho normal quando o cache roda na mesma máquina do wiki. O segundo são as variáveis `$wgUseCdn` e `$wgCdnServers` do core, que enviam a notificação de purga para endereços de cache externos, caso de CDN ou proxy reverso em outro servidor.

Deixe os dois ativos e cada salvamento dispara purga em duplicidade: no melhor caso é desperdício, no pior o `$wgCdnServers` aponta para um endereço que não existe mais, as requisições falham e você passa a culpar a extensão por uma purga que ela estava fazendo certo. Se o cache é local, mantenha só a purga da extensão e deixe `$wgUseCdn` desligado. Se o cache é externo, use `$wgUseCdn` com `$wgCdnServers` apontando para ele.

Em qualquer um dos dois, o salvamento invalida de imediato só a página editada. As páginas que transcluem o conteúdo alterado (templates, infoboxes, listas) entram na job queue pelo `HTMLCacheUpdate` e são invalidadas depois, conforme a fila roda. Em wiki pouco acessado a fila anda devagar, porque ela avança a cada visita. Se uma página dependente continuar mostrando conteúdo antigo por muito tempo, o problema é fila parada, não purga quebrada: rode `php maintenance/runJobs.php` no diretório do wiki para esvaziar a fila na hora.

Na prática: deixe ligada a opção de purga por página no save e **desligada** a de purga total. Reserve a purga total para quando você mudar skin, atualizar o MediaWiki ou instalar extensão que altere o HTML de todas as páginas.

## Testando com curl se a purga chegou no save

O teste não exige ferramenta nenhuma além do `curl`. Escolha um artigo pouco acessado e rode:

```
curl -sI https://seuwiki.exemplo/wiki/Pagina_de_Teste | grep -i x-litespeed-cache
```

O que cada parte faz: `-s` silencia a barra de progresso, `-I` pede só os cabeçalhos (não baixa o HTML), e o `grep -i` filtra a linha do cabeçalho de cache sem diferenciar maiúscula de minúscula.

Resultado esperado, em sequência:

- **Primeira chamada:** `x-litespeed-cache: miss`. O cache estava vazio, a página foi renderizada agora.
- **Segunda chamada, logo em seguida:** `x-litespeed-cache: hit`. O HTML veio do cache.
- **Edite e salve a página no wiki.** Rode o comando de novo: precisa voltar para `miss`.
- **Quarta chamada:** `hit` outra vez, agora com o conteúdo novo.

Se o passo 3 continuar devolvendo `hit`, a purga no save não está chegando. Com cache local, confira se a variável de purga da extensão está ligada no `LocalSettings.php`. Com cache externo, confira se `$wgUseCdn` está ativo e se `$wgCdnServers` aponta para o endereço certo. Se nenhuma linha aparecer no `grep`, o cache não está respondendo àquela URL: confira se ela não caiu numa regra de exclusão larga demais.

Para testar o lado oposto, use uma URL que **deve** ficar fora:

```
curl -sI "https://seuwiki.exemplo/index.php?title=Pagina_de_Teste&action=history" | grep -i x-litespeed-cache
```

Aqui o esperado é não haver `hit` nunca. Se aparecer `hit`, a exclusão de `action=history` não pegou.

## Medindo o TTFB antes e depois pela mediana de cinco execuções

Uma linha resolve:

```
curl -s -o /dev/null -w "%{time_starttransfer}\n" https://seuwiki.exemplo/wiki/Pagina_de_Teste
```

`-o /dev/null` descarta o corpo da resposta, e `-w "%{time_starttransfer}"` imprime o tempo, em segundos, até o primeiro byte chegar. É o TTFB: o intervalo em que o servidor pensou.

Rode cinco vezes com o cache desligado, anote, ligue o cache, rode cinco vezes de novo. Compare a mediana, não a média, porque uma chamada ruim distorce a média.

Uma leitura típica tem este formato (os valores abaixo são **exemplo de leitura**, para você saber o que está olhando, e não medição da Napoleon):

```
0.412   <- miss, renderizou
0.038   <- hit
0.035   <- hit
```

O número que importa é o seu. Se o `hit` não ficar claramente abaixo do `miss`, o cache não está sendo usado de fato: repita o teste do cabeçalho da seção anterior antes de concluir qualquer coisa sobre desempenho.

## O que o cache de servidor não conserta

Vale dizer o que o cache de servidor não conserta, para você não trocar de plano à toa:

- **Edição lenta.** Salvar página nunca passa pelo cache. Se o save demora, o gargalo é banco de dados, job queue acumulada ou extensão pesada rodando no hook de save.
- **Busca lenta.** `Special:Search` está na lista de exclusão por definição. Busca lenta se resolve com CirrusSearch ou índice do banco, não com cache de página.
- **Wiki fechado a leitores anônimos.** Se o wiki exige login para ler (caso comum em wiki corporativo), praticamente todo tráfego é autenticado e o cache público não vai pegar quase nada. Aí o ganho vem de parser cache, cache de objeto e job queue, não desta configuração.
- **Primeira visita sempre lenta.** Isso é o `miss` fazendo o trabalho dele. Se incomoda, um TTL mais longo e purga seletiva mantêm mais páginas quentes por mais tempo.

Antes de qualquer mudança de infraestrutura, rode o `curl` de TTFB nas dez páginas mais acessadas e olhe o log de consulta lenta do MySQL. Muita lentidão de wiki é uma query sem índice numa extensão, e nenhum cache esconde isso para o editor logado que precisa salvar.

## Checklist final

- Extensão aparece em `Special:Version`.
- Cache público ligado, cache por usuário logado desligado.
- Exclusões de `action=edit`, `submit`, `history`, `delete`, `protect`, `raw`, `purge`, mais `Special:`, `api.php` e `load.php`.
- Purga por página no save ligada, purga total desligada.
- Um único mecanismo de purga ativo: o nativo da extensão (cache no mesmo servidor) ou `$wgUseCdn` com `$wgCdnServers` (cache externo), nunca os dois.
- Teste `miss` → `hit` → editar → `miss` → `hit` concluído com sucesso.
- TTFB medido antes e depois, com mediana de cinco execuções.

Feito isso, o visitante anônimo recebe HTML pronto e o editor continua vendo a versão real da página. É a única combinação em que wiki rápido e wiki correto convivem.

