# Deixar a loja OpenCart mais rápida com cache sem vazar carrinho

Você mede a página de categoria com o cache desligado, escreve as exclusões de rota nas duas formas que o OpenCart serve a mesma página, e só então liga o cache. A ordem importa tanto quanto a regra.

> seis famílias de rota precisam ficar fora do cache no OpenCart (checkout/*, account/*, product/compare, api/*, common/currency e common/language), cada uma nas duas formas que a loja serve, query string e URL SEO, mais a variação por cookie de moeda e idioma.

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

---

## O que este guia faz, e o que ele não faz

Este é um guia documental. A Napoleon Host não mediu esta loja, não mediu uma loja de teste e não tem número de laboratório para este tema. Todo valor de tempo que aparecer no texto é **exemplo de formato de saída do comando**, não resultado de medição nossa. O número que vale é o que você vai coletar na sua própria loja, com o seu tema, os seus módulos e o seu servidor.

O procedimento está na ordem inversa da maioria dos tutoriais de propósito. Primeiro você mede a página de categoria com o cache **desligado**, três vezes, anotando os três valores. Depois escreve as regras de exclusão de rota. Só no último passo você liga o cache e repete exatamente a mesma medição. Se você ligar antes, perde a linha de base e nunca mais saberá quanto o cache ganhou, nem se ganhou.

O risco de errar aqui não é o site ficar lento. É a página de um visitante ser servida para outro. No OpenCart, o total do carrinho fica dentro do HTML do cabeçalho, em quase todos os temas. Uma página de categoria em cache público guarda o cabeçalho de quem gerou aquela cópia. É por isso que a lista de rotas precisa estar completa nas duas formas, e é por isso que existe o bypass por cookie no final.

A referência oficial da extensão de cache para OpenCart é a [documentação do LSCache for OpenCart](https://docs.litespeedtech.com/lscache/lscoc/). Se você usa a extensão, configure as exclusões na tela dela. As regras de `.htaccess` deste guia servem para quem controla o cache no nível do servidor, sem a extensão, ou para quem precisa entender o que a extensão está fazendo por baixo.

### A sintaxe de .htaccess aqui depende do servidor ser LiteSpeed

Os parâmetros de variável de ambiente usados adiante (`E=Cache-Control:no-cache` e `E=Cache-Vary:...`) são sintaxe de reescrita do servidor web, não fazem parte da configuração da extensão e não estão descritos na documentação do LSCache for OpenCart, que trata da tela da extensão. Antes de colocar esses blocos em produção, confirme com quem administra o seu servidor que ele interpreta essas variáveis e que o `.htaccess` é o lugar certo para elas na sua configuração. Se o servidor não for LiteSpeed, a sintaxe é outra e o arquivo é outro. A lógica da tabela de rotas, essa sim, vale em qualquer servidor.

### Faça a cópia do .htaccess antes de tocar em qualquer arquivo

Faça uma cópia do `.htaccess` da raiz da loja. Pelo gerenciador de arquivos do painel, clique com o botão direito no arquivo, escolha Copiar e salve como `.htaccess.bak` na mesma pasta. Se a loja quebrar (erro 500 em toda página), renomear `.htaccess.bak` de volta para `.htaccess` resolve em segundos. Esse é o caminho de volta. Não comece sem ele.

## Passo 1: meça a página de categoria com o cache desligado

Escolha uma página de categoria com produtos, não a home. Categoria é a página que mais sofre com consulta ao banco e é a que melhor mostra o efeito do cache.

### Confirme que o cache está mesmo desligado antes de medir

No painel do OpenCart, vá em **Extensões > Extensões > Módulos** e verifique se a extensão de cache está desativada. No painel de hospedagem, confira se o cache de página do servidor está desligado para o domínio. E confirme pelo cabeçalho da resposta:

```bash
curl -sI 'https://sualoja.com.br/categoria-exemplo' | grep -i 'x-litespeed-cache'
```

Com o cache desligado, esse comando não devolve nada. Se devolver `x-litespeed-cache: hit`, existe cache ativo e a sua medição "antes" está contaminada. Desligue e limpe o cache antes de continuar.

### Rode a medição três vezes e entenda cada opção do curl

```bash
for i in 1 2 3; do
  curl -o /dev/null -s -w '%{time_starttransfer}\n' 'https://sualoja.com.br/categoria-exemplo'
  sleep 2
done
```

Linha a linha:

- `for i in 1 2 3; do ... done` repete o comando três vezes.
- `curl` faz a requisição como um visitante que nunca esteve no site (sem cookie nenhum).
- `-o /dev/null` joga fora o HTML baixado, você não quer ver a página.
- `-s` esconde a barra de progresso.
- `-w '%{time_starttransfer}\n'` imprime **só** o tempo, em segundos, entre o início da requisição e a chegada do primeiro byte do corpo da resposta. Esse valor inclui DNS, conexão, TLS e o tempo que o PHP levou para montar a página. É o que se costuma chamar de TTFB.
- `sleep 2` dá dois segundos entre as execuções.

A saída são três números, um por linha, no formato `0.412857`. Esses seis dígitos são exemplo de formato, não uma medição nossa.

No Windows, dentro do PowerShell, `curl` é apelido de outro comando e ignora essas opções. Use `curl.exe` no lugar de `curl`, ou rode pelo terminal de uma máquina Linux ou Mac.

### Anote os três valores antes de escrever qualquer regra

Copie para uma tabela. Você vai preencher a coluna da direita só no passo 4.

| Execução | TTFB com cache desligado | TTFB com cache ligado |
|---|---|---||
| 1 |  |  |
| 2 |  |  |
| 3 |  |  |

O primeiro valor de cada bateria tende a ser o maior, porque o PHP e o banco ainda não estão aquecidos. Por isso três execuções, e por isso você anota as três, não a média.

## As seis famílias de rota que ficam fora do cache, nas duas formas

O OpenCart serve a mesma página por dois endereços diferentes. A forma canônica é a query string, `index.php?route=checkout/cart`. Se as SEO URLs estiverem ligadas no painel (**Sistema > Configurações > editar loja > aba Servidor > Usar SEO URLs**), a mesma página também atende em um caminho limpo, e nesse caminho **a query string `route=` não existe**. Uma regra que olha só para a query string não pega o caminho limpo. Uma regra que olha só para o caminho não pega quem chega pelo link antigo, pelo formulário ou por um módulo que monta a URL na forma completa. Você precisa das duas.

| Rota (forma canônica) | O que é | Caminho SEO equivalente (exemplo) | Por que fica fora do cache |
|---|---|---|---||
| `index.php?route=checkout/cart` | carrinho | `/carrinho` | conteúdo por sessão |
| `index.php?route=checkout/checkout` | finalização | `/finalizar-compra` | conteúdo por sessão, dados pessoais |
| `index.php?route=checkout/success` | pedido concluído | `/pedido-confirmado` | única por pedido |
| `index.php?route=account/login` | login | `/login` | token de formulário |
| `index.php?route=account/register` | cadastro | `/cadastro` | token de formulário |
| `index.php?route=account/account` | painel do cliente | `/minha-conta` | dados pessoais |
| `index.php?route=account/order` | histórico de pedidos | `/meus-pedidos` | dados pessoais |
| `index.php?route=account/wishlist` | lista de desejos | `/lista-de-desejos` | conteúdo por sessão |
| `index.php?route=product/compare` | comparador | `/comparar` | conteúdo por sessão |
| `index.php?route=api/...` | API usada pelo admin ao criar pedido | não tem | resposta transacional |
| `index.php?route=common/currency` | troca de moeda | não tem | grava cookie e redireciona |
| `index.php?route=common/language` | troca de idioma | não tem | grava cookie e redireciona |

Os caminhos SEO da terceira coluna são **exemplo fictício**. Cada loja define os seus na tabela `seo_url`, e a maioria das instalações não cria caminho limpo para carrinho e conta, só para produto, categoria e página de informação. Não presuma nada. Abra a loja em uma aba anônima, clique em cada uma das páginas da tabela e copie da barra de endereços o que aparecer de verdade. O que você copiar é o que entra na regra.

Duas observações sobre a tabela. `api/` só é usado pelo painel administrativo ao criar ou editar pedido, mas cair em cache quebra a criação de pedido pelo admin, então entra na lista. `common/currency` e `common/language` recebem um POST, gravam cookie e redirecionam. Se a resposta do redirecionamento ficar em cache, a troca de moeda passa a funcionar uma vez só e depois nunca mais.

## Passo 2: escreva as regras de exclusão no .htaccess

Abra o `.htaccess` da raiz da loja (a mesma pasta do `index.php`) pelo gerenciador de arquivos do painel, em Editar. O bloco abaixo entra **acima** das regras de SEO URL do OpenCart, aquelas que terminam em `index.php?_route_=$1`. Acima, porque nesse ponto a query string ainda é a original e as condições conseguem enxergar `route=`.

Os quatro blocos a seguir (A1, A2, B e os do passo 3) formam **um único bloco `<IfModule LiteSpeed>`**. A abertura aparece em A1 e o fechamento só aparece no último trecho do passo 3. Não feche antes, ou as regras seguintes ficam fora do contexto e o servidor as ignora. Se preferir montar por partes, cole tudo em um editor de texto, monte o bloco inteiro e só então salve no `.htaccess`.

### Bloco A1: checkout, conta e API na forma com query string

```apache
<IfModule LiteSpeed>
RewriteEngine On

# A1: cobre index.php?route=checkout/*, account/* (inclusive account/wishlist)
#     e api/*, em qualquer posição da query string.
RewriteCond %{QUERY_STRING} route=(checkout|account|api)/ [NC]
RewriteRule .* - [E=Cache-Control:no-cache]
```

O que A1 cobre: qualquer URL cuja query string contenha `route=checkout/`, `route=account/` ou `route=api/`. Isso inclui `checkout/cart`, `checkout/checkout`, `checkout/success`, `account/login`, `account/order` e `account/wishlist`, porque todos são subcaminhos dos três prefixos.

O que A1 **não** cobre: `product/compare`, `common/currency` e `common/language`. Não foram incluídos de propósito. Se a condição listasse o prefixo `product/`, ela derrubaria o cache de todas as páginas de produto, que são justamente as que você quer em cache. Se listasse `common/`, derrubaria `common/home`, a página inicial. Por isso existe a linha seguinte, que nomeia as três rotas inteiras em vez do prefixo.

### Bloco A2: comparador, troca de moeda e troca de idioma

```apache
# A2: cobre product/compare, common/currency e common/language, rotas
#     completas. Não usa prefixo para não derrubar product/* e common/home.
RewriteCond %{QUERY_STRING} route=(product/compare|common/currency|common/language) [NC]
RewriteRule .* - [E=Cache-Control:no-cache]
```

O que A2 cobre: exatamente as três rotas nomeadas, na forma com query string.

O que A2 **não** cobre: nenhuma dessas páginas quando ela é servida por caminho SEO, porque nesse caso não existe `route=` na query string. Por isso existe o bloco B.

### Bloco B: as mesmas páginas servidas por caminho SEO

```apache
# B: cobre os caminhos limpos. Os slugs abaixo são EXEMPLO.
#    Troque pelos caminhos reais copiados da barra de endereços da sua loja.
RewriteCond %{REQUEST_URI} ^/(carrinho|finalizar-compra|pedido-confirmado|login|cadastro|minha-conta|meus-pedidos|lista-de-desejos|comparar)(/|$) [NC]
RewriteRule .* - [E=Cache-Control:no-cache]
```

Repare que **não há `</IfModule>` aqui**. O fechamento vem no passo 3, depois das regras de cookie.

O que B cobre: os caminhos limpos que você listou, e tudo abaixo deles, por causa do `(/|$)` no final. `/minha-conta/enderecos` cai na regra junto com `/minha-conta`.

O que B **não** cobre: caminho que você esqueceu de listar. Não existe curinga seguro aqui, porque os slugs são livres e um `^/(c.*)` derrubaria toda categoria começada com a letra c. Se a loja tem mais de um idioma com slugs diferentes por idioma, cada slug precisa aparecer na lista. `api/`, `common/currency` e `common/language` não aparecem em B porque não recebem caminho SEO no OpenCart padrão, eles já estão cobertos por A1 e A2.

Não salve ainda: termine o passo 3, feche o `<IfModule>` e só então grave o arquivo. Depois de salvar, abra a loja em uma aba anônima e navegue por cinco páginas diferentes, incluindo carrinho e login. Se aparecer erro 500, restaure o `.htaccess.bak` e revise a sintaxe, quase sempre é parêntese, colchete ou `</IfModule>` faltando.

## Passo 3: o bypass por cookie e a variação por moeda

Regra por URL falha em dois casos previsíveis: um módulo que serve conteúdo de sessão dentro de uma página pública, e um caminho SEO que você não listou. O cookie é a rede de segurança para esses dois casos.

O OpenCart usa três cookies que interessam ao cache: `OCSESSID`, que identifica a sessão (e portanto o carrinho e o login), `currency`, que guarda a moeda escolhida, e `language`, que guarda o idioma.

As duas regras abaixo continuam o mesmo bloco iniciado em A1, na ordem em que aparecem: primeiro o `Cache-Vary`, depois o bypass por sessão, e só então o `</IfModule>`.

### Varie o cache por moeda e idioma em vez de desligá-lo

Moeda e idioma não devem gerar bypass, devem gerar **cópias separadas** de cache. A mesma categoria em real e em dólar são duas páginas diferentes, e as duas merecem ficar em cache.

```apache
# Continua dentro do mesmo <IfModule LiteSpeed>, logo após o bloco B.
# Uma cópia de cache por combinação de moeda e idioma.
RewriteRule .* - [E=Cache-Vary:currency,language]
```

O que essa linha cobre: impede que a versão em dólar seja entregue para quem escolheu real, e vice-versa. O que ela **não** cobre: carrinho e login, que continuam dependendo das regras de rota e do item abaixo.

### O bypass por OCSESSID derruba quase todo o ganho do cache

```apache
# Última parte do bloco. O </IfModule> abaixo fecha o <IfModule LiteSpeed>
# aberto no bloco A1. Leia o parágrafo seguinte antes de deixar esta
# regra ligada em definitivo.
RewriteCond %{HTTP_COOKIE} OCSESSID [NC]
RewriteRule .* - [E=Cache-Control:no-cache]
</IfModule>
```

Seja honesto sobre o custo: o OpenCart abre sessão no primeiro acesso, então praticamente todo visitante ganha `OCSESSID` já na primeira página. Com essa regra ligada, o cache serve a primeira página de cada visita e mais nada. O ganho de velocidade despenca. Ela é uma rede de segurança temporária, útil enquanto você valida as regras de rota, não uma configuração final. Para desligá-la depois, comente as duas linhas com `#` na frente e salve.

O caminho melhor, quando o tema mostra o total do carrinho no cabeçalho, é deixar esse pedaço do HTML fora do cache em vez de deixar a página inteira fora. A extensão de cache tem configuração própria para esse cenário, na tela dela dentro do painel do OpenCart: abra as opções da extensão e procure os campos de exclusão e de conteúdo dinâmico antes de escrever qualquer regra à mão. Se você usa a extensão, configure lá e não duplique a regra no `.htaccess`: duas camadas decidindo a mesma coisa é a receita para um comportamento que ninguém consegue explicar depois.

Se o seu servidor não é LiteSpeed, a lógica da tabela de rotas continua idêntica, a sintaxe muda. Nginx com cache de FastCGI e Apache com módulo de cache usam diretivas próprias e ficam fora do `.htaccess`. Confirme com quem administra o servidor qual é o arquivo certo antes de escrever qualquer coisa.

## Passo 4: ligue o cache e repita a mesma medição

Agora sim. Ative o cache de página, seja pela extensão no painel do OpenCart, seja pela opção do painel de hospedagem. Limpe o cache existente logo após ativar, para começar do zero.

### Repita o comando do passo 1 sem mudar nada

```bash
for i in 1 2 3; do
  curl -o /dev/null -s -w '%{time_starttransfer}\n' 'https://sualoja.com.br/categoria-exemplo'
  sleep 2
done
```

Mesma URL, mesmo comando, mesma máquina, de preferência no mesmo horário do dia. Preencha a coluna da direita da tabela do passo 1.

O primeiro dos três valores costuma ser o mais alto, porque essa execução é quem popula o cache. A comparação honesta é entre a execução 2 e 3 com cache ligado e as três com cache desligado. Se as três com cache ligado forem iguais entre si e iguais às de antes, o cache não está sendo usado. Veja o item seguinte.

### Confirme que a categoria sai de miss para hit

```bash
curl -sI 'https://sualoja.com.br/categoria-exemplo' | grep -i 'x-litespeed-cache'
```

Na primeira execução o valor esperado é `miss`, na segunda `hit`. Se ficar em `miss` para sempre, alguma regra está derrubando o cache dessa página: o bypass por `OCSESSID` (mas o `curl` não manda cookie, então não é ele), um slug de categoria que por acidente casa com a lista do bloco B, ou o cache não está realmente ativo.

### Confirme que as rotas excluídas nunca respondem hit

```bash
curl -sI 'https://sualoja.com.br/index.php?route=checkout/cart' | grep -i 'x-litespeed-cache'
curl -sI 'https://sualoja.com.br/carrinho' | grep -i 'x-litespeed-cache'
```

Rode cada um duas vezes. Em nenhuma das execuções pode aparecer `hit`. Se aparecer, a rota não está coberta: a primeira URL é problema no bloco A1, a segunda é slug faltando no bloco B. Repita para `account/login`, `product/compare` e para o caminho SEO de cada uma, se existir.

## Validação manual: prove que nenhum carrinho vazou

Cabeçalho de resposta prova regra. Só o navegador prova o comportamento real.

- Navegador A, janela normal: adicione dois produtos ao carrinho. O cabeçalho deve mostrar 2 itens.
- Navegador B, janela anônima, outro navegador de preferência: abra a mesma categoria e a home. O cabeçalho tem que mostrar 0 itens. Se mostrar 2, o cabeçalho com carrinho está sendo cacheado e você precisa do tratamento do passo 3.
- Navegador B: abra `/index.php?route=checkout/cart`. O carrinho tem que estar vazio.
- Navegador A: troque a moeda. Recarregue uma categoria. Os preços têm que mudar e continuar mudados depois de três recarregamentos.
- Navegador B: confirme que a moeda dele não mudou.
- Faça um pedido de teste completo, do carrinho ao `checkout/success`, com pagamento em modo de teste ou boleto. A página de sucesso tem que mostrar o número do pedido certo.
- No painel administrativo, crie um pedido manualmente. É isso que exercita `api/`. Se falhar, a rota de API está em cache.

Esse roteiro leva menos de dez minutos e é o único que pega o erro que custa pedido. Guarde a lista: ela é o teste de regressão para toda vez que você trocar de tema, instalar módulo novo ou mexer nas regras de cache.

## Quando o cache não é o problema e o que olhar no lugar dele

Se a sua medição do passo 1, com cache desligado, já der um TTFB baixo, o cache de página vai melhorar pouco e você estaria trocando de plano ou instalando extensão para resolver o que não está quebrado. Nesse caso o tempo que o visitante percebe está em outro lugar, e vale investigar nesta ordem:

- **Peso da página.** Abra as ferramentas de desenvolvedor do navegador, aba Rede, e olhe o total transferido e a quantidade de requisições. Vinte imagens de produto sem compressão pesam mais que qualquer ganho de TTFB.
- **Consulta lenta no banco.** Cache de página esconde consulta lenta, não conserta. Loja com muitos filtros e muitos atributos costuma ter uma consulta que domina o tempo. Se o seu painel dá acesso ao log de consultas lentas, olhar ele primeiro resolve sem trocar nada de plano.
- **Extensão de terceiro.** Desative uma por vez em ambiente de teste e refaça a medição de três execuções. É lento e é o único método que dá resposta confiável.
- **Distância até o servidor.** Parte do `time_starttransfer` é conexão e TLS. Se você mede do outro lado do país, o número inclui essa viagem. Medir de dentro da mesma região onde estão seus clientes dá um retrato mais próximo do real.

Cache de página resolve o custo de montar o HTML repetidamente. Quando esse custo é pequeno, guarde o esforço para outro lugar. Quando é grande, o ganho aparece entre a coluna esquerda e a direita da sua tabela, e aí você tem o número, o seu, medido antes e depois, com as rotas certas fora do caminho.

