Explicação sobre Cache HTTP: Cache-Control, ETag, Imagens e Configuração do Apache
Aprenda a configurar o cache do navegador para HTML, CSS, JavaScript, imagens e fontes. Entenda ETag e respostas 304 com exemplos práticos, evite arquivos desatualizados e utilize uma configuração completa do Apache .htaccess.
Cache HTTP Explicado: Cache-Control, ETag, Imagens e Configuração do Apache
Você otimiza suas imagens, minifica seu CSS e comprime seu JavaScript. Seu site carrega mais rápido. Mas quando os visitantes retornam, seus navegadores podem baixar os mesmos arquivos novamente.
Você ativa o cache. Tudo parece melhor — até você substituir uma imagem e descobrir que alguns visitantes ainda veem a antiga.
Esse é o desafio do cache HTTP: reutilizar arquivos que não mudaram, mas buscar novas versões quando mudam.
Neste guia, vamos construir uma estratégia de cache para um site real usando Apache, PHP e as ferramentas de desenvolvedor do navegador.
1. Cache HTTP explicado com um exemplo simples
Imagine um site com cinco arquivos:
index.html
assets/css/style.css
assets/js/app.js
assets/images/hero.webp
assets/fonts/site.woff2
Quando alguém visita seu site pela primeira vez, o navegador baixa esses arquivos.
Agora imagine que o visitante retorna dez minutos depois.
Se o servidor anteriormente informou ao navegador que o arquivo CSS poderia ser reutilizado por um dia, o navegador não precisa baixá-lo novamente.
O navegador já tem uma cópia.
Essa é a ideia básica do cache.
As instruções vêm dos cabeçalhos HTTP enviados com a resposta do servidor.
Por exemplo:
Cache-Control: public, max-age=86400
Isso significa que a resposta pode ser reutilizada enquanto estiver válida por 86.400 segundos — um dia.
Mas o que acontece se você atualizar o CSS depois de apenas uma hora?
O navegador pode continuar usando a versão antiga pelas 23 horas restantes.
É por isso que simplesmente aumentar as durações de cache não é suficiente.
2. Cache-Control: as instruções enviadas ao navegador
O cabeçalho Cache-Control informa aos navegadores e a outros caches HTTP como lidar com uma resposta.
Aqui estão as diretivas que você usará com mais frequência.
| Diretiva | Explicação simples |
|---|---|
max-age=3600 |
Reutilizar a resposta por até uma hora |
public |
Caches compartilhados, incluindo CDNs, podem armazenar a resposta |
private |
Armazenar apenas em um cache privado, não em um compartilhado |
no-cache |
Armazenar se permitido, mas validar antes de reutilizar |
no-store |
Não armazenar a resposta |
immutable |
O recurso não deve mudar enquanto estiver válido |
must-revalidate |
Depois de obsoleta, não reutilizar sem validação bem-sucedida |
Uma diretiva particularmente confusa é no-cache.
Ela não significa "nunca armazene este arquivo".
Significa "antes de usar uma cópia armazenada, pergunte ao servidor se ela ainda é válida".
Para respostas que não devem ser armazenadas, use no-store.
Essa distinção importa ao configurar páginas HTML e conteúdo sensível.
3. ETag explicado: como o navegador pergunta se um arquivo mudou
Vamos tornar isso concreto.
Imagine que você tem um arquivo chamado logo.webp.
O navegador o baixa na segunda-feira.
O servidor também envia um identificador:
ETag: "logo-version-1"
Pense nesse identificador como um rótulo anexado àquela versão específica da imagem.
O navegador mantém a imagem e lembra do rótulo.
Na terça-feira, a resposta em cache precisa de validação. Em vez de baixar imediatamente a imagem inteira novamente, o navegador pergunta:
"Olá servidor, eu já tenho a imagem identificada por logo-version-1. Ela ainda é a mesma?"
Tecnicamente, ele envia:
GET /images/logo.webp HTTP/1.1
Host: example.com
If-None-Match: "logo-version-1"
O servidor compara esse identificador com a versão atual.
Caso A: a imagem não mudou
O servidor responde:
HTTP/1.1 304 Not Modified
ETag: "logo-version-1"
O navegador diz, na prática, "Ótimo, vou continuar usando minha imagem existente."
O servidor não envia o corpo da imagem novamente.
Caso B: a imagem mudou
Suponha que você substitua o logotipo por uma nova versão.
O servidor agora o identifica como logo-version-2.
O navegador ainda pergunta sobre logo-version-1, mas o servidor responde:
HTTP/1.1 200 OK
Content-Type: image/webp
ETag: "logo-version-2"
Desta vez, a resposta inclui a nova imagem.
O navegador substitui sua cópia em cache.
É isso que o ETag faz pelo cache: ele ajuda o navegador a verificar se sua cópia ainda está atualizada.
O identificador não precisa ser um hash ou um número de versão. O Apache pode gerá-lo a partir de metadados do arquivo, e aplicações podem gerar seus próprios identificadores.
Teste o ETag você mesmo
Primeiro, recupere os cabeçalhos da resposta:
curl -I https://example.com/images/logo.webp
Encontre o ETag:
ETag: "abc123"
Depois envie uma requisição condicional:
curl -I \
-H 'If-None-Match: "abc123"' \
https://example.com/images/logo.webp
Se a representação estiver inalterada, um servidor corretamente configurado pode retornar 304 Not Modified.
Se mudou, espere 200 OK com a representação atualizada.
Uma limitação importante: o ETag não força o navegador a contatar o servidor enquanto uma resposta em cache ainda estiver válida. Se uma imagem tem uma vida útil de um ano, mudar o arquivo no servidor não garante que o navegador verificará seu ETag imediatamente.
É aí que o versionamento de recursos se torna essencial.
4. Cache de imagens: a parte que frequentemente causa mais problemas
Imagens são frequentemente alguns dos maiores recursos em um site.
Uma página inicial pode conter uma imagem de destaque, ilustrações de categorias, miniaturas de artigos, logotipos, ícones e imagens de produtos.
Mesmo quando comprimidas em WebP ou AVIF, baixá-las repetidamente desperdiça banda.
Vamos examinar três situações reais.
Situação A: uma imagem que nunca muda
Seu site tem uma imagem decorativa:
/images/background-v1.webp
Você sabe que, sempre que o design mudar, usará um novo nome de arquivo.
Você pode configurar com segurança:
Cache-Control: public, max-age=31536000, immutable
O navegador pode reutilizá-la por um ano sem contatar o servidor enquanto a resposta estiver válida.
Situação B: uma imagem substituída sob o mesmo nome de arquivo
Seu artigo contém:
<img src="/images/article-hero.webp" alt="Article illustration">
Você substitui article-hero.webp por uma nova imagem, mas mantém a mesma URL.
Se o navegador tem uma resposta em cache válida com uma vida útil longa, ele pode continuar exibindo a imagem antiga.
A solução é mudar a URL quando o conteúdo muda.
Por exemplo:
<img src="/images/article-hero.webp?v=2" alt="Article illustration">
Ou, melhor ainda, gerar um nome de arquivo versionado:
<img src="/images/article-hero-a81c.webp" alt="Article illustration">
Agora o navegador vê uma URL de recurso diferente e solicita a nova imagem.
A imagem antiga em cache é inofensiva porque o HTML não a referencia mais.
Situação C: milhares de imagens com nomes de arquivo estáveis
Imagine um site editorial contendo milhares de artigos.
Renomear cada imagem manualmente seria inconveniente.
Você pode, em vez disso, escolher uma vida útil de cache moderada, como um dia ou uma semana, e confiar na revalidação após a expiração.
Por exemplo:
Cache-Control: public, max-age=86400
Esse é um compromisso razoável quando o versionamento automático de imagens não está disponível.
No entanto, os visitantes ainda podem ver uma imagem mais antiga durante o período de validade.
Para imagens que devem atualizar imediatamente, uma URL alterada ou uma invalidação explícita de cache é preferível.
E quanto a JPEG, PNG, SVG, WebP e AVIF?
O princípio de cache é idêntico para todos eles.
| Formato de imagem | Uso típico | Estratégia de cache |
|---|---|---|
| JPEG | Fotos | Cache longo se a URL for versionada |
| PNG | Gráficos, transparência | Igual |
| WebP | Imagens web otimizadas | Igual |
| AVIF | Imagens altamente comprimidas | Igual |
| SVG | Ícones, logotipos, ilustrações | Igual |
| GIF | Animações simples | Igual |
O formato afeta a compressão e a decodificação, mas não muda fundamentalmente o comportamento do cache HTTP.
Lembre-se também de que imagens responsivas podem produzir várias entradas de cache independentes:
<picture>
<source
type="image/avif"
srcset="/images/hero-640.avif 640w,
/images/hero-1280.avif 1280w">
<source
type="image/webp"
srcset="/images/hero-640.webp 640w,
/images/hero-1280.webp 1280w">
<img
src="/images/hero-1280.jpg"
alt="Mountain landscape"
width="1280"
height="720">
</picture>
Cada URL selecionada tem seu próprio comportamento de cache.
Se você substituir a imagem, atualize as URLs de todas as variantes relevantes.
5. Versionar automaticamente CSS, JavaScript e imagens com PHP
Para sites em PHP, você pode evitar atualizar manualmente os números de versão usando o tempo de modificação do arquivo.
Aqui está um pequeno auxiliar:
<?php
function assetUrl(string $path): string
{
$file = $_SERVER['DOCUMENT_ROOT'] . $path;
if(!is_file($file)) {
return $path;
}
return $path . '?v=' . filemtime($file);
}
Use-o assim:
<link rel="stylesheet" href="<?= htmlspecialchars(assetUrl('/assets/css/site.css'), ENT_QUOTES, 'UTF-8') ?>">
<img
src="<?= htmlspecialchars(assetUrl('/assets/images/hero.webp'), ENT_QUOTES, 'UTF-8') ?>"
alt="Hero image">
Suponha que o timestamp de modificação do arquivo seja 1794800000.
O navegador recebe uma URL como:
/assets/images/hero.webp?v=1794800000
Quando você atualiza o arquivo e seu tempo de modificação muda, a URL muda também.
Esta é uma estratégia simples de cache-busting.
Para pipelines de build de produção, hashes de conteúdo são mais robustos porque os timestamps podem ser preservados durante as implantações ou mudar sem que o conteúdo mude.
Importante: se o seu CDN está configurado para ignorar strings de consulta em sua chave de cache, ?v= pode não produzir um recurso em cache distinto. Verifique a configuração do CDN ou use nomes de arquivo versionados em vez disso.
6. Não confunda cache do navegador, cache do servidor e cache do CDN
Um site pode ter várias camadas de cache.
O cache do navegador armazena respostas no dispositivo do visitante.
Um CDN armazena respostas selecionadas em servidores geograficamente mais próximos dos visitantes.
Um cache de aplicação pode armazenar HTML gerado, resultados de consultas de banco de dados ou outros dados computados.
Essas camadas resolvem problemas diferentes.
Por exemplo, um CDN pode servir uma imagem desatualizada mesmo depois de o cache do navegador ser limpo.
Da mesma forma, limpar o cache de um CMS não necessariamente invalida uma imagem já armazenada por um navegador ou CDN.
Ao depurar, identifique qual camada está servindo o conteúdo antigo antes de alterar a configuração.
7. Desempenho de hospedagem e cache HTTP
O cache HTTP pode reduzir significativamente os downloads repetidos, mas não pode compensar todo problema de hospedagem.
Por exemplo, se uma página PHP sem cache leva dois segundos para ser gerada por causa de consultas de banco de dados lentas, o cache de imagens pelo navegador não resolverá o tempo de resposta subjacente do servidor.
Um ambiente de hospedagem confiável deve fornecer desempenho PHP adequado, armazenamento, compressão, TLS e suporte a cabeçalhos de cache.
Para sites pequenos e médios, um provedor de hospedagem como PlanetHoster pode fazer parte de uma configuração prática.
Para aplicações que exigem mais controle sobre recursos do servidor, fluxos de trabalho de implantação ou arquitetura de cache, Cloudways também pode valer a pena avaliar.
Antes de trocar de provedor, meça o gargalo real: tempo de resposta do servidor, peso das imagens, execução do PHP, consultas de banco de dados ou configuração de cache.
8. Como inspecionar o cache no Firefox e no Chrome
Abra as ferramentas de desenvolvedor do seu navegador.
No Firefox, pressione F12, depois selecione Network.
Recarregue seu site e clique em uma requisição de imagem ou de folha de estilo.
Observe seus cabeçalhos de resposta.
Por exemplo:
Cache-Control: public, max-age=86400
ETag: "abc123"
Last-Modified: Mon, 16 Nov 2026 09:00:00 GMT
Agora repita a navegação sem desabilitar o cache.
Dependendo do navegador, da validade do recurso e de como a navegação foi iniciada, ele pode ser carregado do cache local, revalidado com um 304, ou baixado novamente.
Para testar uma imagem específica de forma independente:
curl -sS -D - -o /dev/null \
https://example.com/assets/images/hero.webp
Verifique o status, Cache-Control, ETag e Last-Modified.
Depois repita a requisição com If-None-Match usando o ETag real retornado pelo seu servidor.
Evite usar um recarregamento forçado como seu único teste de cache: ele pode deliberadamente ignorar ou revalidar respostas em cache.
9. Exemplo completo de Apache .htaccess para um site real
Vamos terminar com uma configuração prática.
Este exemplo foi projetado para um site público rodando Apache 2.4, com uma mistura de arquivos estáticos e HTML gerado por PHP.
A estratégia é deliberadamente conservadora:
- O HTML é revalidado.
- CSS e JavaScript usam um cache de sete dias.
- As imagens usam um cache de sete dias.
- As fontes usam um cache mais longo.
- Os arquivos de manifesto usam um cache curto.
- O ETag permanece disponível para validação de arquivos estáticos.
- As respostas do PHP podem definir suas próprias políticas.
Esta é uma configuração inicial, não um substituto universal de encaixe direto. Verifique as regras existentes do provedor de hospedagem, os módulos habilitados e as permissões de sobrescrita do Apache antes de implantá-la.
# ============================================================
# HTTP CACHING — APACHE 2.4
# Example configuration for a public website
# ============================================================
# ------------------------------------------------------------
# 1. Static file expiration
# ------------------------------------------------------------
<IfModule mod_expires.c>
ExpiresActive On
# Default: validate immediately
ExpiresDefault "access plus 0 seconds"
# HTML: validate before reuse
ExpiresByType text/html "access plus 0 seconds"
# CSS and JavaScript: 7 days
ExpiresByType text/css "access plus 7 days"
ExpiresByType text/javascript "access plus 7 days"
ExpiresByType application/javascript "access plus 7 days"
# Images: 7 days
ExpiresByType image/jpeg "access plus 7 days"
ExpiresByType image/png "access plus 7 days"
ExpiresByType image/gif "access plus 7 days"
ExpiresByType image/webp "access plus 7 days"
ExpiresByType image/avif "access plus 7 days"
ExpiresByType image/svg+xml "access plus 7 days"
ExpiresByType image/x-icon "access plus 7 days"
ExpiresByType image/vnd.microsoft.icon "access plus 7 days"
# Fonts: 30 days
ExpiresByType font/woff "access plus 30 days"
ExpiresByType font/woff2 "access plus 30 days"
ExpiresByType font/ttf "access plus 30 days"
ExpiresByType font/otf "access plus 30 days"
# Documents: 1 day
ExpiresByType application/pdf "access plus 1 day"
# JSON and XML: validate immediately by default
ExpiresByType application/json "access plus 0 seconds"
ExpiresByType application/xml "access plus 0 seconds"
ExpiresByType text/xml "access plus 0 seconds"
# Web manifest: 1 hour
ExpiresByType application/manifest+json "access plus 1 hour"
</IfModule>
# ------------------------------------------------------------
# 2. Explicit Cache-Control for static resources
# ------------------------------------------------------------
<IfModule mod_headers.c>
# HTML: allow storage, require validation
<FilesMatch "\.html?$">
Header set Cache-Control "no-cache"
</FilesMatch>
# CSS and JavaScript
<FilesMatch "\.(css|js|mjs)$">
Header set Cache-Control "public, max-age=604800"
</FilesMatch>
# Images
<FilesMatch "\.(jpe?g|png|gif|webp|avif|svg|ico)$">
Header set Cache-Control "public, max-age=604800"
</FilesMatch>
# Fonts
<FilesMatch "\.(woff2?|ttf|otf)$">
Header set Cache-Control "public, max-age=2592000"
</FilesMatch>
# PDF documents
<FilesMatch "\.pdf$">
Header set Cache-Control "public, max-age=86400"
</FilesMatch>
# Data files: revalidate
<FilesMatch "\.(json|xml)$">
Header set Cache-Control "no-cache"
</FilesMatch>
# Manifest files
<FilesMatch "\.webmanifest$">
Header set Cache-Control "public, max-age=3600"
</FilesMatch>
</IfModule>
# ------------------------------------------------------------
# 3. ETag support for static files
# ------------------------------------------------------------
FileETag MTime Size
# ------------------------------------------------------------
# 4. Compression
# ------------------------------------------------------------
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE text/javascript
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/json
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE image/svg+xml
</IfModule>
# ------------------------------------------------------------
# 5. Avoid caching sensitive PHP responses accidentally
# ------------------------------------------------------------
# Configure dynamic PHP responses in application code.
# Do not apply public caching globally to PHP endpoints.
Notas importantes sobre esta configuração
1. Não duplique uma configuração de cache existente.
Se o seu provedor de hospedagem, CMS ou plugin de cache já define esses cabeçalhos, mescle as políticas com cuidado.
O mod_expires do Apache gera informações de expiração e max-age, enquanto o mod_headers pode definir explicitamente o Cache-Control. Dependendo de como os cabeçalhos são gerados e armazenados internamente, combinar ambos pode produzir valores duplicados ou conflitantes.
Inspecione a resposta HTTP real e simplifique a configuração se necessário. Para uma implantação de produção, escolher um mecanismo consistente para cada classe de recurso é preferível.
2. ETag não é obrigatório para toda resposta.
A diretiva FileETag MTime Size se aplica aos arquivos servidos pelo Apache. Ela não fornece automaticamente validadores significativos para páginas PHP geradas dinamicamente.
Em servidores distribuídos, os ETags baseados em metadados também podem exigir consideração adicional.
3. Compressão não é otimização de imagem.
O Gzip é útil para recursos baseados em texto, como HTML, CSS, JavaScript, JSON e SVG.
JPEG, WebP, AVIF e PNG já são formatos comprimidos. Compressão gzip adicional geralmente fornece pouco benefício.
Se o seu servidor já suporta Brotli, evite adicionar configurações de compressão concorrentes sem verificar a configuração existente.
4. Sete dias é um compromisso.
Se todos os seus recursos estáticos têm URLs confiavelmente versionadas, você pode estender a vida útil de seu cache para um ano e usar immutable.
Se você rotineiramente substitui imagens sem mudar suas URLs, sete dias ainda pode ser muito longo.
Escolha a política com base em como seu site é implantado.
10. Teste a configuração antes e depois da implantação
Use esta lista de verificação.
| Teste | Resultado esperado |
|---|---|
| Solicitar uma imagem | Cache-Control reflete a política de imagem |
| Solicitar uma folha de estilo | Política de cache CSS correta |
| Solicitar HTML | Política de revalidação |
| Solicitar uma página privada | Nenhum cache compartilhado acidental |
Enviar If-None-Match |
304 se inalterada e a validação for suportada |
| Substituir uma imagem versionada | A nova URL carrega a nova imagem |
| Inspecionar CSS comprimido | Codificação de conteúdo apropriada |
| Verificar o painel Network do navegador | Nenhum download completo repetido inesperado |
Por exemplo:
curl -I https://example.com/assets/images/hero.webp
Depois:
curl -I https://example.com/assets/css/site.css
E finalmente:
curl -I https://example.com/
Compare os cabeçalhos de resposta.
Se um arquivo não tem o cabeçalho de cache esperado, verifique se o Apache está realmente servindo-o, se o módulo relevante está habilitado e se um CDN ou camada de aplicação sobrescreve a resposta.
Se o site retorna um 500 Internal Server Error após editar o .htaccess, restaure a configuração anterior e inspecione o log de erros do Apache. Diretivas não suportadas ou sobrescritas não permitidas são causas comuns.
11. Quando um CDN ou hospedagem gerenciada se torna útil
Para sites com visitantes em diferentes países, um CDN pode reduzir a distância entre os usuários e os recursos estáticos em cache.
No entanto, adicionar um CDN não é automaticamente uma melhoria.
Primeiro, certifique-se de que as imagens estejam corretamente dimensionadas e comprimidas, de que o cache do navegador funcione e de que as URLs dos recursos estáticos estejam versionadas.
Depois meça se o CDN melhora os tempos reais de entrega.
Uma plataforma de hospedagem com controles de cache adequados pode simplificar essa configuração, mas você ainda deve entender qual camada de cache é responsável por cada resposta.
PlanetHoster e Cloudways são duas opções de hospedagem que valem a pena avaliar dependendo dos requisitos da aplicação, das necessidades operacionais e dos controles de servidor disponíveis.
A pergunta importante não é qual provedor anuncia mais recursos de cache. É se você consegue configurar, medir e invalidar conteúdo em cache de forma confiável.
Conclusão
O cache HTTP se torna muito mais fácil de gerenciar quando você separa três perguntas:
Esta resposta pode ser armazenada? Por quanto tempo pode ser reutilizada sem verificação? Como o navegador sabe se ela mudou?
O Cache-Control responde às duas primeiras perguntas.
ETag e requisições condicionais ajudam a responder à terceira.
Para recursos estáticos como imagens, CSS e JavaScript, URLs versionadas são frequentemente a maneira mais confiável de combinar longas vidas úteis de cache com atualizações imediatas.
Para HTML e conteúdo que muda frequentemente, a revalidação é geralmente mais apropriada.
Comece com uma configuração conservadora, teste-a com requisições HTTP reais e só aumente as vidas úteis de cache quando entender como o site lida com atualizações.