Cache DNS no sistema e no aplicativo: por que trocar o proxy não muda a resolução — guia passo a passo para limpar
Sumário do artigo
- Introdução: o que você vai aprender e para quem serve este guia
- Preparação inicial: ferramentas, acessos e backups
- Conceitos básicos: como um nome vira endereço e onde ele trava
- Passo 1: diagnóstico — descobrindo qual camada segura o endereço antigo
- Passo 2: limpando o cache dns do sistema no linux, windows e macos
- Passo 3: limpando o cache dns do navegador e o pool de conexões
- Passo 4: gerenciando o cache dns na jvm e em aplicações java
- Passo 5: entendendo caches em outros runtimes, utilitários e no lado do proxy
- Passo 6: ajustando o ttl e automatizando a limpeza
- Verificação do resultado: checklist e cenário de teste completo
- Erros comuns e soluções
- Recursos extras para usuários avançados
- Faq: perguntas frequentes sobre cache dns e limpeza
- Conclusão
Introdução: o que você vai aprender e para quem serve este guia
Cena conhecida: você trocou o proxy no sistema ou no aplicativo, atualizou a página e o site continua abrindo pelo endereço antigo, mostra a região errada ou simplesmente ignora as novas configurações. A primeira reação costuma ser: o proxy não está funcionando. Na prática, na maioria dos casos o proxy está perfeito. O problema é que, em algum lugar entre o seu programa e a rede, existe um cache DNS que já memorizou a resposta e não vai perguntar de novo até o tempo de vida da entrada expirar.
Este guia é dedicado justamente aos caches. Não vamos entrar na questão da resolução remota via proxy nem na diferença entre os esquemas socks5 e socks5h: esse é um assunto extenso à parte, já abordado em outro artigo. Aqui seguimos por outra camada do problema: por que, mesmo com o proxy configurado corretamente, o IP antigo continua vivo no sistema, onde exatamente ele fica armazenado e como expulsá-lo de lá de forma garantida.
O que você vai conseguir ao final. Depois de percorrer este guia, você será capaz de identificar em poucos minutos qual cache está segurando a entrada antiga: o resolvedor do sistema, o serviço nscd, o navegador, a máquina virtual Java ou o pool de conexões do aplicativo. Você vai aprender a limpar cada um desses caches no Linux, Windows e macOS, a ajustar o tempo de vida das entradas conforme a sua necessidade e a conferir o resultado sem margem para dúvida.
Para quem é este guia. Para desenvolvedores, testadores, administradores e todos que trabalham regularmente com proxy, testam sites de diferentes regiões, migram serviços para novos endereços ou depuram problemas de rede. Nível intermediário: você já conhece comandos básicos de terminal, mas não precisa de conhecimento profundo de DNS. Os blocos avançados estão sinalizados separadamente e podem ser pulados na primeira leitura.
O que você precisa saber antes. Como abrir o terminal ou o prompt de comando no seu sistema, como executar comandos com privilégios administrativos e o que é um endereço IP. O resto explicamos ao longo do caminho.
Quanto tempo vai levar. O percurso completo com verificações leva de 40 a 60 minutos. Se você só precisa limpar o cache em um ponto específico, encontre o passo correspondente e resolva em 5 minutos.
Preparação inicial: ferramentas, acessos e backups
Antes de começar, garanta que tudo o que você precisa está à mão. A lista é curta, mas cada item importa: sem privilégios administrativos você não limpa o cache do sistema, e sem a ferramenta dig fica difícil ver o TTL das entradas.
Ferramentas necessárias
- Terminal com privilégios administrativos. No Linux e no macOS, isso é o sudo; no Windows, é o prompt de comando ou o PowerShell iniciado como administrador.
- Utilitários dig e nslookup. No Linux, o dig faz parte do pacote dnsutils (Debian e Ubuntu) ou bind-utils (Fedora, RHEL). No macOS, o dig já vem instalado. No Windows existe o nslookup, e o dig pode ser obtido no pacote BIND ou substituído pelo comando PowerShell Resolve-DnsName.
- Utilitário curl. Presente nas versões atuais do Windows 11, do macOS e em quase todas as distribuições Linux de 2026.
- Navegador. Serve o Chrome, qualquer navegador baseado em Chromium ou o Firefox. Vamos cobrir as duas famílias.
- Java Development Kit versão 17, 21 ou 25, caso você planeje fazer o passo sobre a JVM. Se você não usa Java, pode pular esse passo.
- Acesso ao servidor proxy com o qual você trabalha: endereço, porta, login e senha. Vamos alternar o proxy para observar o efeito dos caches.
- Domínio de teste. O ideal é um domínio cujo registro A você possa alterar, ou um domínio com resposta dependente de região. Se não tiver um, serve qualquer site grande com CDN: esses domínios costumam responder de forma diferente por região.
Requisitos de sistema
O guia foi testado no Ubuntu 24.04 e 26.04, Debian 13, Fedora 43, Windows 11 com as atualizações atuais de 2026 e macOS 15 ou superior. Em outros sistemas os comandos podem variar um pouco, mas a lógica é a mesma.
Instalando o que falta
- No Ubuntu ou Debian, execute
sudo apt update && sudo apt install dnsutils curl. - No Fedora, execute
sudo dnf install bind-utils curl. - No macOS não é preciso instalar nada. Se quiser, instale o bind pelo Homebrew:
brew install bind. - No Windows, abra o PowerShell como administrador e confirme que o comando
Resolve-DnsName example.comretorna um resultado. Isso já basta.
Backups
Vamos editar arquivos de configuração: java.security, nscd.conf, arquivos no diretório /etc/systemd/resolved.conf.d e o arquivo hosts. Antes de alterar cada arquivo, faça uma cópia. Uma forma universal: sudo cp /caminho/para/arquivo /caminho/para/arquivo.bak. No Windows, basta copiar o arquivo para a mesma pasta com o sufixo .bak pelo Explorador de Arquivos.
Atenção: limpar o cache DNS por si só é seguro e não quebra o sistema. Já desativar sem pensar o serviço systemd-resolved ou o nscd pode deixar você sem resolução de nomes até reiniciar. Não desative serviços, a menos que o guia diga explicitamente o contrário. Vamos apenas limpar o cache e ajustar parâmetros.
Dica: crie um arquivo de texto como diário e registre cada comando e o respectivo resultado. Daqui a meia hora você não vai lembrar qual cache limpou primeiro, e o diário economiza tempo na hora de analisar erros comuns.
Conceitos básicos: como um nome vira endereço e onde ele trava
Para lidar com caches com segurança, é preciso entender quantos existem e por que eles existem. Vamos aos termos principais em linguagem simples.
DNS e resolução
DNS é um diretório distribuído que traduz um nome legível como example.com em um endereço IP com o qual a rede sabe trabalhar. Esse processo de tradução se chama resolução (do inglês resolve). Toda vez que um programa quer se conectar a um site, ele precisa do IP, e ou pergunta ao resolvedor, ou pega do cache.
TTL — o tempo de vida da entrada
TTL (Time To Live) é o número de segundos durante os quais o dono do domínio permite memorizar a resposta. Se o TTL é 300, qualquer cache no caminho tem o direito de guardar o endereço por 5 minutos sem perguntar de novo. Valores típicos: de 60 segundos em serviços que mudam de endereço com frequência até 86400 segundos, ou seja, um dia, em recursos estáveis. Importante: o TTL é o limite superior. O cache pode descartar a entrada antes disso, mas não pode guardá-la por mais tempo. Na prática, alguns caches ignoram o TTL e mantêm a entrada por regras próprias. São justamente esses casos que nos interessam.
Um bolo de camadas de cache
O principal a assimilar: cache DNS não é um único lugar. A consulta de nome passa por várias camadas, e cada uma pode responder da própria memória sem descer mais. Vamos listar as camadas de cima para baixo, do aplicativo à rede.
- Cache do aplicativo. O navegador mantém a própria tabela nome-endereço. A máquina virtual Java faz cache dos resultados de InetAddress. Algumas bibliotecas e frameworks adicionam caches próprios por cima do cache do sistema.
- Pool de conexões. Formalmente não é cache DNS, mas o efeito é o mesmo: o aplicativo já abriu uma conexão TCP com o IP antigo e a reutiliza, sem resolver nada de novo. Navegadores e clientes HTTP fazem isso o tempo todo.
- Resolvedor do sistema e seu cache. No Linux moderno, geralmente é o systemd-resolved, escutando no endereço 127.0.0.53. Em sistemas antigos e mínimos, é o nscd (Name Service Cache Daemon) ou o dnsmasq. No Windows, é o serviço DNS Client. No macOS, é o mDNSResponder.
- Arquivo hosts. Entradas estáticas que sobrepõem o DNS. Não é cache em sentido estrito, mas é uma fonte frequente de surpresas.
- Cache do roteador ou do servidor DNS local na rede do provedor. Não temos como influenciar nele, mas precisamos considerá-lo.
- Servidor autoritativo do domínio. A fonte da verdade, à qual a consulta só chega quando todos os caches acima estão vazios ou expirados.
Por que o proxy não tem nada a ver com isso
O servidor proxy atua na camada de transporte: ele recebe a sua conexão e abre a própria conexão com o destino. A resolução do nome acontece antes disso e por regras próprias. Se o aplicativo resolve o nome sozinho, ele pega o endereço do cache das camadas 1 a 4 e só depois decide se vai direto ou pelo proxy. Trocar o proxy não mexe em nenhum desses caches. As entradas neles vivem a própria vida, e enquanto o TTL não expirar ou o缓存 não for limpo à força, você vai continuar vendo o resultado antigo.
Existe também a situação inversa: ao usar um proxy HTTP com método CONNECT ou um proxy SOCKS com resolução remota, o nome é enviado ao proxy, e é ele quem resolve. Nesse caso os caches locais não participam, mas participa o cache do lado do proxy. Não vamos detalhar esse cenário, mas no passo 5 mostramos como descobrir rapidamente onde exatamente a resolução aconteceu.
Cache negativo
Um termo à parte que costuma confundir: cache negativo (negative cache). Se o resolvedor recebeu a resposta de que o nome não existe, ele memoriza isso também. Na JVM, respostas negativas ficam guardadas 10 segundos por padrão; no systemd-resolved, seguem o TTL do registro SOA do domínio. Por isso, se você acabou de adicionar um domínio e o aplicativo insiste em dizer que o nome não foi encontrado, a causa pode ser justamente o cache negativo.
Passo 1: Diagnóstico — descobrindo qual camada segura o endereço antigo
Objetivo da etapa: aprender a identificar em poucos comandos em qual nível a entrada travou, para não limpar tudo às cegas.
O princípio do diagnóstico é simples: consultamos o mesmo domínio em camadas diferentes e comparamos as respostas. Se o servidor autoritativo dá o endereço novo, o resolvedor do sistema dá o novo, mas o navegador dá o antigo, o culpado está claro.
Consultando a fonte autoritativa
- Abra o terminal.
- Execute
dig example.com A +noall +answer, trocando pelo seu domínio. Você verá uma linha comoexample.com. 287 IN A 93.184.215.14. O segundo campo é o TTL restante em segundos no seu resolvedor. Se o número diminui a cada execução, a resposta vem do cache. - Agora contorne os caches locais e pergunte diretamente a um resolvedor público:
dig @1.1.1.1 example.com A +noall +answer. Compare o endereço e o TTL. - Por fim, descubra o servidor autoritativo do domínio:
dig example.com NS +short. Pegue qualquer nome da lista e pergunte a ele:dig @ns1.example-dns.net example.com A +noall +answer. Aqui o TTL é sempre cheio e o endereço é o mais recente.
No Windows, o equivalente: Resolve-DnsName example.com -Type A para a resolução do sistema e Resolve-DnsName example.com -Type A -Server 1.1.1.1 para contornar o cache local.
Consultando o resolvedor do sistema
- No Linux com systemd-resolved, execute
resolvectl query example.com. No fim da saída haverá uma linha com a origem dos dados: Data from: cache significa que a resposta veio do cache; Data from: network significa que a consulta foi para a rede. - Verifique como programas comuns resolvem pela biblioteca do sistema:
getent hosts example.com. É exatamente esse caminho que o curl sem chaves especiais, o Python, o Go e a maioria dos utilitários usam. Se o resultado for diferente do dig, há mais uma camada no meio: arquivo hosts, nscd ou uma ordem especial em /etc/nsswitch.conf. - No Windows, execute
ipconfig /displaydns | findstr example.com. Se o domínio aparecer na lista, está no cache do serviço DNS Client. - No macOS, execute
dscacheutil -q host -a name example.com. A saída mostra o que exatamente o sistema entrega aos aplicativos.
Consultando o aplicativo
- No Chrome, abra o endereço
chrome://net-internals/#dnse clique no botão Lookup, digitando o domínio no campo ao lado. O resultado mostra se a entrada está no cache do navegador. - No Firefox, abra
about:networking#dns. A tabela mostra todos os nomes em cache, os respectivos endereços e o tempo de vida restante na coluna Expires. - Para verificar qual IP o aplicativo realmente usou, abra
chrome://net-internals/#socketsno Chrome: ali aparecem os soquetes abertos e os endereços de destino.
Verificação: ao final do passo, você deve ter uma tabela de quatro linhas: endereço do servidor autoritativo, endereço do resolvedor do sistema, endereço do getent e endereço do navegador. A divergência entre linhas vizinhas aponta para a camada onde a entrada travou.
Problemas possíveis
- O dig não está instalado. Volte à seção de preparação e instale o pacote dnsutils ou bind-utils. Temporariamente, use
nslookup example.com, mas ele não mostra o TTL. - O resolvectl dá erro de conexão com o barramento. Isso significa que o systemd-resolved não está rodando e o sistema usa outro resolvedor. Confira o conteúdo de /etc/resolv.conf: se não for 127.0.0.53, procure o nscd ou o dnsmasq no passo 2.
- As respostas são iguais em todo lugar, mas o site continua estranho. Provavelmente a culpa é do pool de conexões ou do cache do lado do proxy. Isso está no passo 5.
Dica: a chave +noall +answer do dig elimina a saída extra e deixa só a resposta. Adicione um alias ao seu perfil de shell, por exemplo alias d='dig +noall +answer', e o diagnóstico fica duas vezes mais rápido.
Passo 2: Limpando o cache DNS do sistema no Linux, Windows e macOS
Objetivo da etapa: limpar o cache do sistema operacional de modo que a próxima consulta de qualquer aplicativo vá garantidamente para a rede.
Linux: systemd-resolved
No Ubuntu, Fedora, Debian com configurações padrão e na maioria das distribuições modernas de 2026, quem resolve é o systemd-resolved. Confirme com o comando systemctl is-active systemd-resolved: a resposta active confirma.
- Veja as estatísticas do cache antes da limpeza:
resolvectl statistics. No bloco Cache você verá as linhas Current Cache Size, Cache Hits e Cache Misses. Anote o valor de Current Cache Size. - Limpe o cache:
sudo resolvectl flush-caches. O comando não exibe nada, isso é normal. - Repita
resolvectl statistics. O valor de Current Cache Size deve ir a zero. - Limpe também o cache negativo, caso tenha adicionado um domínio novo. Não existe comando separado: flush-caches limpa tudo de uma vez, incluindo entradas negativas.
- Confira:
resolvectl query example.comdeve mostrar Data from: network no final.
Alternativa, se o resolvectl não estiver disponível: sudo systemctl restart systemd-resolved. O restart leva menos de um segundo e também limpa o cache, mas interrompe a resolução de todos os programas por um instante. No uso interativo isso é imperceptível, mas em um servidor sob carga é melhor usar o flush-caches.
Linux: nscd
O serviço nscd armazena em cache não só o DNS, mas também usuários, grupos e outros dados de /etc/nsswitch.conf. Aparece em instalações antigas, em algumas imagens de servidor e onde foi instalado de propósito. Verifique a presença: systemctl is-active nscd.
- Limpe apenas a tabela de hosts, sem mexer no resto:
sudo nscd -i hosts. A chave -i significa invalidate, ou seja, tornar inválido. - Se o comando não estiver disponível, reinicie o serviço:
sudo systemctl restart nscd. - Confira o resultado com
getent hosts example.com. É o getent que passa pelo nscd, enquanto o dig o contorna.
Atenção: o nscd tem configurações próprias de TTL no arquivo /etc/nscd.conf, e elas podem ser maiores que o TTL da entrada DNS. A linha positive-time-to-live hosts 3600 significa que o nscd vai manter o endereço por uma hora, mesmo que o dono do domínio tenha definido TTL de 60 segundos. Essa é uma das causas mais comuns de o endereço antigo durar mais do que o esperado em servidores. Voltaremos a isso no passo 6.
Linux: dnsmasq
O dnsmasq costuma atuar como resolvedor de cache local em roteadores, em ambientes de contêiner e no NetworkManager de versões antigas. Sinal: em /etc/resolv.conf aparece o endereço 127.0.0.1 ou 127.0.1.1, e o comando pidof dnsmasq retorna o número do processo.
- Limpe o cache com um sinal:
sudo kill -HUP $(pidof dnsmasq). O sinal HUP faz o dnsmasq reler a configuração e limpar o cache. - Ou reinicie o serviço:
sudo systemctl restart dnsmasq.
Windows 11
- Pressione a tecla Windows, digite cmd, clique com o botão direito em Prompt de Comando e escolha Executar como administrador.
- Execute
ipconfig /displaydnspara ver o conteúdo do cache. A lista pode ser longa: role ou filtre comfindstr. - Limpe o cache:
ipconfig /flushdns. Você deve ver a mensagem O cache do resolvedor DNS foi limpo com êxito. - Alternativa no PowerShell:
Clear-DnsClientCachepara limpar eGet-DnsClientCachepara visualizar. A versão em PowerShell é mais prática em scripts.
Se o comando informar que não foi possível limpar o cache, verifique se o serviço DNS Client está em execução: Get-Service Dnscache. O status deve ser Running. Se o serviço estiver parado, o Windows resolve sem cache, e o problema certamente não está aqui.
macOS
- Abra o Terminal: Finder, Programas, Utilitários, Terminal. Ou pressione Cmd+Espaço e digite Terminal.
- Execute
sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder. Digite a senha de administrador quando o sistema pedir. As duas partes são necessárias: a primeira limpa o cache do serviço de diretório, a segunda faz o mDNSResponder limpar o próprio cache. - Não haverá saída. Confira o resultado:
dscacheutil -q host -a name example.comdeve retornar o endereço atualizado.
Verificação: após a limpeza em qualquer sistema, repita o diagnóstico do passo 1. O resolvedor do sistema deve entregar um endereço que coincide com a resposta do servidor autoritativo, e o TTL na primeira consulta deve ser o máximo para essa entrada.
Problemas possíveis
- Depois da limpeza, o endereço continua antigo. Verifique o arquivo hosts: no Linux e no macOS é /etc/hosts; no Windows é C:\Windows\System32\drivers\etc\hosts. Uma entrada ali sobrepõe o DNS por completo. Confira também o cache do resolvedor acima: se
dig @1.1.1.1também retorna o endereço antigo, as alterações do dono do domínio ainda não se propagaram, e será preciso esperar o TTL completo. - O resolvectl flush-caches funcionou, mas o navegador mostra o antigo. Isso é esperado: o navegador não pergunta ao sistema enquanto o próprio cache não expirar. Vá para o passo 3.
Dica: no systemd-resolved existe o parâmetro Cache=no-negative, que desliga o armazenamento de respostas negativas. Para desenvolvedores que criam domínios novos em ambientes de teste com frequência, isso evita erros infinitos de “nome não encontrado” logo após publicar o registro.
Passo 3: Limpando o cache DNS do navegador e o pool de conexões
Objetivo da etapa: fazer o navegador esquecer os endereços antigos e fechar as conexões já abertas com o servidor antigo, para que a nova requisição passe pela cadeia atual de resolução e proxy.
O navegador é a camada mais traiçoeira. Ele armazena endereços em cache independentemente do sistema, mantém conexões abertas em nome da velocidade e ainda pode resolver nomes com o próprio cliente DNS-over-HTTPS, ignorando por completo as configurações do sistema operacional.
Chrome e navegadores baseados em Chromium
- Na barra de endereços, digite
chrome://net-internals/#dnse pressione Enter. - Clique no botão Clear host cache. Não haverá confirmação visual, o botão apenas executa a ação.
- Vá para a aba
chrome://net-internals/#sockets. - Clique em Flush socket pools. Esse botão fecha todas as conexões abertas. Sem ele, o navegador continua enviando requisições pelo canal já estabelecido com o IP antigo, e limpar o DNS não adianta nada.
- Na mesma tela, clique em Close idle sockets para garantir.
- Verifique se o DNS seguro está ativado: abra
chrome://settings/securitye encontre a opção Usar um servidor DNS seguro. Se estiver ativada com um provedor específico, o Chrome resolve por ele, e o cache do sistema e os servidores DNS do sistema não participam de nada. Para testes em que o resolvedor do sistema importa, mude temporariamente a opção para o provedor atual ou desative-a. - Abra o site de teste de novo. De preferência em uma aba nova.
Os endereços citados funcionam no Chrome, Edge, Yandex Browser, Opera e outras builds Chromium em versões atuais de 2026. No Edge, o endereço começa com edge:// em vez de chrome://, o resto é igual.
Firefox
- Digite na barra de endereços
about:networking#dns. - Clique no botão Clear DNS Cache na parte superior da página. A tabela de entradas é limpa na hora.
- Vá para a aba HTTP da mesma página about:networking e veja a lista de conexões ativas. Não há botão separado para fechar, então para limpar o pool de conexões reinicie o Firefox ou alterne para o modo offline e volte: menu, Trabalhar offline, depois desmarque.
- Para controlar o tempo de vida do cache, abra
about:config, confirme o aviso e encontre o parâmetronetwork.dnsCacheExpiration. O valor padrão é 60 segundos. Para depuração, coloque 0: o Firefox para de armazenar nomes em cache. Não esqueça de restaurar o valor depois. - O parâmetro
network.dnsCacheEntriesdefine o número máximo de entradas, 400 por padrão. Não faz sentido reduzi-lo, mas é útil conhecê-lo. - Verifique
network.trr.mode: valor 2 ou 3 significa que o Firefox usa DNS-over-HTTPS e o resolvedor do sistema é ignorado parcial ou totalmente. Para testes limpos do resolvedor do sistema, defina 0 ou 5.
Perfil e modo anônimo como alternativa
Se você precisa testar o site “do zero” rapidamente, abra uma janela anônima ou privada. No Chrome, o cache DNS do modo anônimo é compartilhado com a janela principal, então esse caminho não garante uma resolução limpa; já no Firefox a janela privada tem cache próprio. A opção mais confiável para as duas famílias é um perfil de navegador separado, criado para testes. O perfil inicia com caches vazios e pool de conexões vazio.
Verificação: depois da limpeza, abra chrome://net-internals/#dns e clique em Lookup para o domínio de teste: o endereço deve coincidir com a resposta do servidor autoritativo do passo 1. No Firefox, a tabela about:networking#dns deve mostrar uma entrada nova com o TTL cheio.
Problemas possíveis
- O botão Clear host cache foi clicado, mas o site carrega do servidor antigo. Quase sempre esqueceram o Flush socket pools. A conexão já está aberta, e ela não precisa de DNS.
- O site usa HTTP/3 ou QUIC. Essas conexões podem sobreviver à limpeza dos pools. Desative o QUIC temporariamente em
chrome://flags/#enable-quic, reinicie o navegador e repita o teste. - Uma extensão ou script PAC controla o proxy. A função dnsResolve em arquivos PAC usa o cache do navegador. Se as regras de proxy dependem do IP de destino, um endereço antigo leva a uma rota antiga. Limpe o cache e recarregue o PAC pelas configurações de proxy do sistema.
Dica: adicione as páginas chrome://net-internals/#dns e chrome://net-internals/#sockets aos favoritos na barra. Dois cliques em vez de digitar o endereço economizam bastante tempo em várias trocas de proxy.
Passo 4: Gerenciando o cache DNS na JVM e em aplicações Java
Objetivo da etapa: entender as regras de cache da máquina virtual Java, limpar o cache em uma aplicação em execução e ajustar o TTL para que a troca de proxy ou de endereço seja captada sem reiniciar.
Aplicações Java são conhecidas por “grudar” no IP antigo. A causa é a classe InetAddress, que armazena o resultado da resolução separadamente do sistema. As regras são: respostas bem-sucedidas ficam guardadas 30 segundos; se o gerenciador de segurança estiver ativo, indefinidamente; respostas negativas ficam guardadas 10 segundos. No Java 17, 21 e 25 o gerenciador de segurança está desativado e foi removido nas versões mais novas, então por padrão você lida com 30 segundos. Mas muitas aplicações de servidor alteram esses parâmetros na configuração, e é aí que aparecem valores em horas ou até infinitos.
Olhando a configuração atual
- Localize o arquivo java.security. No JDK 17 e superior ele fica em
$JAVA_HOME/conf/security/java.security. No Windows o caminho é algo comoC:\Program Files\Java\jdk-21\conf\security\java.security. - Abra o arquivo e encontre as linhas
networkaddress.cache.ttlenetworkaddress.cache.negative.ttl. Por padrão, a primeira está comentada e a segunda vale 10. - Verifique os parâmetros de inicialização da aplicação: procure nos scripts e nas units do systemd as chaves
-Dsun.net.inetaddr.ttle-Dsun.net.inetaddr.negative.ttl. São propriedades do sistema que funcionam como alternativa, caso as propriedades de segurança não estejam definidas. - Verifique no código da aplicação se há chamadas a
Security.setPropertycom essas chaves: o código pode sobrepor tudo o que você configurar externamente.
Configurando o TTL
- Faça um backup:
sudo cp $JAVA_HOME/conf/security/java.security $JAVA_HOME/conf/security/java.security.bak. - Abra o arquivo em um editor com privilégios administrativos e descomente ou adicione a linha
networkaddress.cache.ttl=10. Um valor de 10 segundos é um bom meio-termo para aplicações que precisam reagir rápido à troca de endereços. O valor 0 desliga o cache por completo: cada resolução vai ao sistema. O valor -1 ativa o cache indefinido e não serve para os nossos propósitos. - Se necessário, reduza o cache negativo:
networkaddress.cache.negative.ttl=0. Útil em ambientes onde domínios surgem na hora. - Se você não quer mexer no arquivo global do JDK, crie o seu próprio arquivo, por exemplo
/etc/myapp/java.security.override, com as duas linhas de parâmetros, e carregue-o na inicialização com a chave-Djava.security.properties=/etc/myapp/java.security.override. Isso sobrepõe apenas as propriedades indicadas, o resto permanece padrão. - Opção mais rápida, sem editar arquivos: adicione aos parâmetros de inicialização
-Dsun.net.inetaddr.ttl=10 -Dsun.net.inetaddr.negative.ttl=0. Lembre-se de que essas propriedades perdem prioridade para as de java.security, se estas estiverem definidas explicitamente. - Reinicie a aplicação para que os novos parâmetros entrem em vigor.
Atenção: definir o TTL como 0 em um serviço sob alta carga aumenta drasticamente o número de consultas DNS: cada nova conexão fará a resolução do nome. Em sistemas de produção, prefira 10 a 60 segundos, e reserve o valor zero para ambientes de depuração.
Limpando o cache sem reiniciar
Não existe método público de limpar o cache do InetAddress no JDK. No entanto, há abordagens que funcionam.
- Esperar o TTL expirar. Com os 30 segundos padrão, isso é mais rápido que qualquer manipulação. Verifique se ninguém definiu -1.
- Usar um resolvedor próprio. Desde o Java 18 existe a interface InetAddressResolverProvider, pela qual a aplicação pode conectar a própria implementação de resolução, com qualquer lógica de cache e um método explícito de limpeza. É um caminho avançado para quem controla o código.
- Conferir o endereço pelo JShell. Para diagnóstico, execute
jshelle rodeInetAddress.getByName("example.com"). Assim você vê qual endereço a própria JVM entrega com as configurações atuais, independentemente do sistema.
Pools de conexão em Java
Como no navegador, os clientes Java têm pools: o HttpClient da biblioteca padrão, o Apache HttpClient, o OkHttp, drivers de banco de dados. Mesmo depois de limpar o DNS, a conexão com o IP antigo permanecerá no pool até fechar por timeout de ociosidade. Se a aplicação precisa mudar para o endereço novo imediatamente, configure no pool um idle-timeout curto ou chame o fechamento do pool a partir de um endpoint administrativo, se existir.
Verificação: inicie a aplicação com os novos parâmetros, altere o registro A do domínio de teste ou reajuste o hosts, aguarde o TTL definido mais alguns segundos e confirme pelos logs ou pelo jshell que a aplicação recebeu o endereço novo.
Dica: em contêineres baseados em imagens Eclipse Temurin e similares, o arquivo java.security fica no caminho padrão, mas reconstruir a imagem só por duas linhas é chato. Use a variável de ambiente JAVA_TOOL_OPTIONS com as chaves -D necessárias: a JVM as captura automaticamente na inicialização, sem alterar o comando de execução.
Passo 5: Entendendo caches em outros runtimes, utilitários e no lado do proxy
Objetivo da etapa: cobrir os lugares restantes onde o endereço antigo pode se esconder: bibliotecas Python, Node.js e Go, o utilitário curl, servidores web, além de entender quando a resolução não acontece com você, mas no proxy.
Python, Node.js, Go
Boa notícia: as bibliotecas padrão dessas linguagens não têm cache DNS próprio. O Python pelo módulo socket, o Node.js pelo dns.lookup e o Go pelo pacote net consultam o resolvedor do sistema pela função getaddrinfo por padrão. Isso significa que, para eles, o passo 2 basta. Há detalhes.
- Node.js. Algumas bibliotecas, como o cacheable-lookup, usado por clientes HTTP populares, adicionam cache próprio. Procure nas dependências do projeto e configure o parâmetro maxTtl. O Node.js também tem a classe dns.Resolver, que consulta servidores DNS diretamente, contornando o resolvedor do sistema: nesse caso o cache do sistema não participa, mas o getent também não ajuda no diagnóstico.
- Go. Compilado com CGO_ENABLED=0, o Go usa o próprio resolvedor puro, que lê /etc/resolv.conf e /etc/hosts, mas não consulta o nscd e o systemd-resolved via NSS. Ele não tem cache, mas o http.Transport mantém pool de conexões keep-alive. Para forçar a reconexão, chame CloseIdleConnections.
- Python. A biblioteca requests com o adaptador padrão reutiliza conexões dentro da sessão. Crie uma sessão nova após trocar o proxy ou feche a antiga com o método close.
curl
O curl tem chaves que ajudam a testar sem influência de cache.
curl -v https://example.com/— na saída detalhada, a linha Trying 93.184.215.14:443 mostra a qual IP a conexão realmente vai.curl --resolve example.com:443:203.0.113.10 https://example.com/— insere o endereço desejado para o nome, contornando o DNS por completo. Insuperável para testar um servidor novo antes da troca do registro.curl --dns-servers 1.1.1.1 https://example.com/— força a resolução pelo servidor indicado, contornando o cache do sistema. Funciona só se o curl foi compilado com a biblioteca c-ares; verifique na saída decurl -Vse aparece a palavra AsynchDNS.
nginx e outros servidores web
O nginx resolve nomes na diretiva proxy_pass uma vez na inicialização e guarda o endereço para sempre, se o nome estiver escrito de forma estática. Para que os endereços se atualizem, defina resolver 127.0.0.53 valid=30s; no bloco http ou server e use uma variável no proxy_pass: assim o nginx vai re-resolver o nome a cada 30 segundos. Mecanismos parecidos existem no HAProxy e no Envoy. Se você trocou o endereço do backend e o nginx continua usando o antigo, recarregue a configuração: sudo nginx -s reload.
Onde a resolução realmente aconteceu: localmente ou no proxy
Este ponto conecta nosso guia ao tema da resolução remota, sem se aprofundar nele. A forma rápida de descobrir quem resolveu o nome é olhar a saída detalhada do cliente.
- Execute
curl -v -x http://user:pass@proxy.example:8080 https://example.com/. Se na saída você vir a linha CONNECT example.com:443 HTTP/1.1 e não houver linha tentando conectar ao IP do site de destino, o nome foi enviado ao proxy como texto, e foi o proxy quem resolveu. Seus caches locais não participaram, mas o cache do lado do proxy ou do resolvedor dele pode ter sido usado. - Execute
curl -v -x socks5://user:pass@proxy.example:1080 https://example.com/. Nesse caso o curl resolve o nome localmente, e você verá o IP do destino na saída. Aqui seus caches dos passos 2 a 4 têm papel integral. - O esquema socks5h envia o nome ao proxy. Detalhes e consequências para a privacidade estão em um artigo à parte sobre DNS via proxy; para a nossa tarefa basta guardar a regra: se o nome é resolvido no proxy, não adianta limpar os caches locais; é preciso esperar o TTL do lado do proxy ou trocar de servidor proxy.
Verificação: para cada ferramenta que você usa, você deve saber dizer onde acontece a resolução e se a ferramenta tem cache ou pool próprio. Registre isso no seu diário em forma de tabela: ferramenta, local da resolução, presença de cache, comando de limpeza.
Dica: ao trocar de proxy em serviços de proxy móvel, o IP do nó de saída pode mudar por agendamento ou por solicitação via link de troca de IP. O cache DNS do seu lado não é limpo nesse processo. Se você está testando como o site reage a diferentes endereços de saída, feche sempre o pool de conexões após cada troca, senão a conexão antiga continua indo pelo canal anterior.
Passo 6: Ajustando o TTL e automatizando a limpeza
Objetivo da etapa: fazer com que os caches não atrapalhem o seu trabalho o tempo todo: definir limites razoáveis de armazenamento das entradas e preparar um script que limpa todas as camadas com um único comando.
Limitando o cache do systemd-resolved
- Crie o diretório de sobreposição, caso não exista:
sudo mkdir -p /etc/systemd/resolved.conf.d. - Crie o arquivo
/etc/systemd/resolved.conf.d/cache.confcom o conteúdo: a linha[Resolve], depoisCache=yes, depoisCacheFromLocalhost=no. Se quiser desligar completamente o cache durante a depuração, troque a primeira diretiva porCache=no. - Reinicie o serviço:
sudo systemctl restart systemd-resolved. - Confirme a aplicação:
resolvectl statusmostra os parâmetros atuais. O systemd-resolved não tem parâmetro separado de TTL máximo, o serviço respeita o TTL das entradas, mas não acima de um teto interno. Para a maioria das tarefas isso basta.
Limitando o cache do nscd
- Faça um backup:
sudo cp /etc/nscd.conf /etc/nscd.conf.bak. - Abra /etc/nscd.conf e encontre o bloco hosts. Defina
positive-time-to-live hosts 60enegative-time-to-live hosts 5. Isso limita o armazenamento de endereços a um minuto e o de erros a cinco segundos. - Se você precisa do nscd só para usuários e grupos, mas não para DNS, coloque
enable-cache hosts no. A resolução de nomes passará direto pelo resolvedor do sistema. - Reinicie o serviço:
sudo systemctl restart nscd.
Script de limpeza completa para Linux
Crie o arquivo ~/bin/dnsflush.sh e torne-o executável com chmod +x ~/bin/dnsflush.sh. Conteúdo do script, linha por linha:
- A primeira linha declara o interpretador:
#!/usr/bin/env bash. systemctl is-active --quiet systemd-resolved && sudo resolvectl flush-caches && echo "resolved: ok"systemctl is-active --quiet nscd && sudo nscd -i hosts && echo "nscd: ok"pidof dnsmasq >/dev/null && sudo kill -HUP $(pidof dnsmasq) && echo "dnsmasq: ok"resolvectl statistics 2>/dev/null | grep -i "Current Cache Size"
O script verifica quais serviços estão ativos e limpa apenas esses. Execute-o após cada troca de proxy ou de endereço.
Script para Windows
Crie o arquivo dnsflush.ps1 com duas linhas: Clear-DnsClientCache e Get-DnsClientCache | Measure-Object | Select-Object -ExpandProperty Count. A segunda linha exibe o número de entradas após a limpeza, que deve ser zero ou próximo disso. Execute no PowerShell como administrador. Se o sistema proibir a execução de scripts, libere para o usuário atual: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned.
Script para macOS
Crie o arquivo dnsflush.sh com a linha sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder; echo "macOS DNS cache flushed". Torne-o executável com chmod e execute pelo Terminal.
Perfil de navegador de teste com cache desativado
Para o Chrome, crie um atalho de inicialização com os parâmetros --user-data-dir=/tmp/chrome-test --host-resolver-rules="MAP example.com 203.0.113.10". A primeira chave cria um perfil separado e limpo, a segunda associa rigidamente nome e endereço durante a sessão, o que é útil ao testar um servidor novo. Para o Firefox, crie um perfil separado pelo about:profiles e nele defina network.dnsCacheExpiration como 0.
Verificação: execute o seu script de limpeza e logo depois rode resolvectl query example.com ou o equivalente no seu sistema. A origem dos dados deve ser network, e o número de entradas na estatística do cache deve ser zero.
Dica: se você troca de proxy com frequência na mesma sessão de trabalho, associe o script de limpeza a uma tecla de atalho pelas configurações do ambiente de desktop. Um toque em vez de três comandos reduz bastante o risco de esquecer alguma camada.
Verificação do resultado: checklist e cenário de teste completo
Vamos ao teste final, que confirma que você controla todas as camadas. Ele leva cerca de 10 minutos.
Checklist
- Você sabe qual resolvedor do sistema é usado na sua máquina e sabe limpar o cache dele com um comando.
- Você sabe ver o TTL de uma entrada com dig ou Resolve-DnsName e entende de onde vem a resposta: do cache ou da rede.
- Você limpa o cache DNS e o pool de conexões do navegador e sabe que, sem o segundo, o primeiro não serve para nada.
- Suas aplicações Java iniciam com networkaddress.cache.ttl definido explicitamente, e não com as configurações padrão.
- Você tem um script de limpeza completa para o seu sistema.
- Você consegue, com um único comando curl, determinar se o nome é resolvido localmente ou no proxy.
Cenário de teste completo
- Adicione ao arquivo hosts uma linha com o domínio de teste e um endereço propositalmente errado, por exemplo 203.0.113.99. Isso simula o “endereço antigo”.
- Abra o domínio no navegador e confirme que a conexão não é estabelecida ou vai para o endereço falso. Verifique em chrome://net-internals/#dns que a entrada foi armazenada em cache.
- Remova a linha do hosts.
- Atualize a página sem limpar nada. Esperado: o navegador continua usando o endereço falso. É a demonstração do problema.
- Execute o script de limpeza do cache do sistema.
- Atualize a página de novo. Esperado: ainda o endereço antigo, porque o cache do navegador não foi tocado.
- Execute Clear host cache e Flush socket pools.
- Atualize a página. Esperado: o site abre pelo endereço correto. Isso confirma que você entende a ordem das camadas.
- Repita os itens 1 a 8 com o jshell em vez do navegador, se você trabalha com Java, observando o efeito do TTL.
Indicadores de sucesso
Cada camada se comporta de forma previsível, você consegue dizer de antemão qual resultado a próxima consulta vai dar, e surpresas após trocar de proxy não acontecem mais. Se em algum passo o resultado for diferente do esperado, volte à seção de diagnóstico e encontre a camada que você deixou passar.
Erros comuns e soluções
Limpei o cache do sistema, mas o navegador mostra o site antigo
Causa: o navegador tem cache DNS próprio e conexões abertas. Solução: Clear host cache mais Flush socket pools no Chrome; Clear DNS Cache mais reiniciar no Firefox. Verifique se o DNS-over-HTTPS está ativado no navegador: nesse caso o resolvedor do sistema não participa de nada.
A aplicação Java mantém o IP antigo por horas
Causa: em java.security ou nos parâmetros de inicialização está definido networkaddress.cache.ttl=-1, ou a aplicação o define no código. Solução: encontre e altere o valor para 10 a 60 segundos, reinicie a aplicação. Verifique também o pool do cliente HTTP: conexões com o IP antigo duram até o idle-timeout.
O comando resolvectl não é encontrado ou não conecta
Causa: o sistema não usa o systemd-resolved. Solução: veja /etc/resolv.conf. O endereço 127.0.0.1 indica dnsmasq ou outro cache local; endereços do provedor significam ausência de cache local. Siga a subseção correspondente do passo 2.
O domínio novo não resolve, embora o registro já esteja publicado
Causa: o cache negativo memorizou a resposta de que o nome não existe. Solução: limpe o cache do sistema; no systemd-resolved, adicione Cache=no-negative; na JVM, defina networkaddress.cache.negative.ttl=0. Verifique se o registro aparece no servidor autoritativo com dig e o servidor indicado.
O getent mostra um endereço e o dig mostra outro
Causa: entre eles há o arquivo hosts ou o nscd com TTL próprio. Solução: verifique /etc/hosts e /etc/nsswitch.conf, limpe o nscd com nscd -i hosts e, se necessário, limite o positive-time-to-live em nscd.conf.
Depois de trocar o IP no proxy móvel, o site vê o endereço de saída anterior
Causa: não é DNS, é conexão viva: o navegador ou o cliente continua operando pelo canal TCP já aberto pelo caminho antigo. Solução: feche o pool de conexões, desative o QUIC durante o teste e, em scripts, crie uma sessão nova após cada troca.
O curl via socks5 mostra o IP local do destino, mas via proxy HTTP não
Causa: no esquema socks5 sem o sufixo h o nome é resolvido localmente; no HTTP CONNECT é resolvido no proxy. É comportamento normal, não é erro. Solução: entenda onde a resolução acontece e limpe o cache correspondente; detalhes em um artigo à parte sobre resolução remota.
O Windows diz que não conseguiu limpar o cache
Causa: o prompt de comando não foi iniciado como administrador ou o serviço Dnscache está parado. Solução: reinicie o terminal como administrador; verifique o status do serviço com Get-Service Dnscache e inicie-o, se preciso.
Recursos extras para usuários avançados
Observando o cache em tempo real
No Linux, o comando sudo resolvectl monitor exibe todas as consultas DNS que passam pelo systemd-resolved, indicando se a consulta foi para a rede. Deixe-o aberto em outra janela e troque o proxy no navegador: você vai ver com os próprios olhos quais consultas o navegador faz e quais ele pega do próprio cache, sem chegar ao sistema. É a forma mais didática de entender a natureza em camadas dos caches.
Namespaces de rede para testes limpos
Com ip netns é possível criar um namespace de rede isolado, com resolv.conf próprio e sem caches compartilhados. Executar o navegador ou o curl dentro desse namespace garante que nenhum cache do sistema interfira no resultado. A configuração exige experiência, mas para testes comparativos regulares com proxies diferentes compensa muito.
Log de resolução na JVM
A chave -Djava.net.preferIPv4Stack=true simplifica o diagnóstico ao retirar o IPv6 da equação, e a flag -Xlog:net em versões recentes do JDK ajuda a ver eventos de rede. Para uma análise mais profunda, use o Java Flight Recorder com eventos de E/S de rede.
Resolvedor de cache próprio
Se você administra um servidor e quer controlar o TTL de forma centralizada para todas as aplicações, suba um Unbound ou Knot Resolver local com os parâmetros cache-max-ttl e cache-min-ttl. Assim os aplicativos do sistema terão comportamento previsível, independentemente do que o dono do domínio definiu. Considere que reduzir o TTL contra a vontade do dono do domínio é uma prática polêmica; use-a apenas em ambientes de teste.
Limpeza automática ao trocar de proxy
Se você troca de proxy por script, adicione a chamada ao script de limpeza do passo 6 ao final do procedimento de troca. Para o navegador, automatizar o clique nos botões é mais difícil: use perfis separados para cada configuração ou inicie o navegador com a flag --host-resolver-rules, que torna o cache previsível.
FAQ: perguntas frequentes sobre cache DNS e limpeza
É preciso reiniciar o computador depois de limpar o cache?
Não. Todos os comandos do guia têm efeito imediato. Reiniciar também limpa os caches, mas é o método mais lento e não ajuda se o problema estiver no TTL do nscd ou na JVM com cache indefinido: depois de reiniciar, eles voltam a armazenar a primeira resposta.
Como descubro qual é o TTL do meu domínio?
Execute dig com o servidor autoritativo indicado: dig @ns1.seuservidor dominio A +noall +answer. O segundo campo da resposta é o TTL completo. A resposta de um resolvedor comum mostra o tempo restante, que diminui a cada segundo.
Limpar o cache pode prejudicar o sistema?
Não. O cache é um armazenamento temporário, e o sistema o preenche de novo. O único efeito colateral é uma breve lentidão no primeiro acesso a cada site. Prejudicial seria apenas desligar os serviços de resolução por completo, o que não fazemos.
Por que o Chrome não tem um TTL separado para o cache DNS, como o Firefox?
O Chrome respeita o TTL da entrada, mas não acima de 60 segundos para respostas positivas, e não permite alterar isso pelas configurações. O controle possível é apenas a limpeza via net-internals ou flags de inicialização como --host-resolver-rules.
Como limpar o cache DNS em um contêiner Docker?
Por padrão, o contêiner não tem resolvedor de cache próprio e consulta o DNS interno do Docker no endereço 127.0.0.11 ou os servidores do resolv.conf do host. O DNS interno do Docker armazena pouco em cache. Se a aplicação dentro do contêiner for Java, configure a JVM. Se for preciso limpar o cache do host, faça isso no host.
O que fazer se o TTL do domínio for de um dia e eu precisar testar o endereço novo agora?
Não espere: use curl com a chave --resolve ou o Chrome com a flag --host-resolver-rules, ou adicione temporariamente uma entrada no hosts. As três abordagens contornam o DNS e permitem testar o servidor novo imediatamente. Não esqueça de remover a entrada do hosts depois do teste.
A troca de proxy influencia o cache DNS de alguma forma?
Diretamente, não. Nenhum dos caches abordados acompanha as configurações de proxy. A única influência indireta: se a resolução é feita no proxy, com um proxy novo você também herda o cache dele, então a resposta pode ser diferente. Mas os caches locais permanecem como estavam.
Como saber se a entrada antiga é mantida pelo provedor e não por mim?
Pergunte diretamente a um resolvedor público: dig com o servidor 1.1.1.1 ou 8.8.8.8 indicado. Se a resposta coincidir com a do servidor autoritativo e o resolvedor do sistema der outra, o problema está na sua máquina. Se os resolvedores públicos também derem o endereço antigo, as alterações ainda não se propagaram, e resta esperar o TTL.
É preciso mudar algo no celular ao testar com proxy móvel?
O celular como fonte de tráfego do proxy não é abordado neste guia; você trabalha com ele como nó remoto. Já no dispositivo de onde você testa, valem todas as camadas descritas. Se testar pelo celular, alterne o modo avião por alguns segundos: isso limpa o cache DNS do sistema no iOS e no Android, e reinicie o navegador do celular.
Conclusão
Vamos resumir. Você entendeu que a resolução de nomes e o funcionamento do proxy são camadas diferentes, e que trocar o proxy não obriga a mudar o resultado da resolução. Você aprendeu a diagnosticar o problema em quatro comandos, comparando as respostas do servidor autoritativo, do resolvedor do sistema, da chamada de biblioteca e do aplicativo. Você sabe limpar o cache do systemd-resolved, do nscd, do dnsmasq, do serviço DNS Client no Windows e do mDNSResponder no macOS. Você limpa o cache e o pool de conexões do navegador, controla o TTL na JVM via java.security e propriedades de sistema, e sabe onde se escondem caches no curl, no nginx e em bibliotecas populares. E o mais importante: você tem um script que faz tudo isso com um único comando.
O que fazer a seguir. Adote o hábito: trocou o proxy ou o endereço, execute a limpeza, feche o pool de conexões, confira com dig. Em uma semana isso vira automático, e o problema “trocar o proxy não muda a resolução” deixa de existir para você.
Para onde evoluir. O próximo passo lógico é o artigo sobre DNS via proxy e resolução remota: lá você vai aprender a fazer o nome ser resolvido no lado do proxy e quais consequências isso traz. Depois, vale estudar o funcionamento do DNS-over-HTTPS em navegadores e sistemas, porque esse mecanismo intercepta a resolução do sistema operacional cada vez com mais frequência. E, por fim, dominar os namespaces de rede no Linux vai te dar uma ferramenta para testes comparativos absolutamente limpos. Boa sorte, e que seus registros se atualizem sempre na hora certa.