Introducción: qué vas a obtener y a quién le sirve esta guía

Una situación conocida: cambiaste el proxy en el sistema o en la aplicación, actualizaste la página y el sitio sigue abriéndose desde la dirección antigua, mostrando la región anterior o simplemente ignorando la nueva configuración. Lo primero que uno piensa es: el proxy no funciona. En la práctica, en la mayoría de los casos el proxy está perfectamente bien. Lo que pasa es que en algún punto entre tu programa y la red hay una caché DNS que ya memorizó la respuesta y no piensa volver a preguntar hasta que venza el tiempo de vida del registro.

Esta guía está dedicada precisamente a las cachés. No vamos a analizar la resolución remota a través del proxy ni la diferencia entre los esquemas socks5 y socks5h: ese es un tema aparte y grande, y ya está desarrollado en otro artículo. Aquí abordamos otra capa del problema: por qué incluso con un proxy bien configurado la IP antigua sigue viva en el sistema, dónde se almacena exactamente y cómo expulsarla de ahí sin lugar a dudas.

Qué vas a obtener al final. Después de completar la guía podrás determinar en un par de minutos cuál caché exactamente está reteniendo el registro antiguo: el resolutor del sistema, el servicio nscd, el navegador, la máquina virtual de Java o el pool de conexiones de la aplicación. Aprenderás a limpiar cada una de estas cachés en Linux, Windows y macOS, a configurar el tiempo de vida de los registros según tus tareas y a verificar el resultado para que no quede ninguna duda.

Para quién es esta guía. Para desarrolladores, testers, administradores y todos los que trabajan regularmente con proxies, prueban sitios desde distintas regiones, migran servicios a nuevas direcciones o depuran problemas de red. Nivel intermedio: conoces los comandos básicos de la terminal, pero no se requieren conocimientos profundos de DNS. Los bloques avanzados están marcados aparte y puedes omitirlos en la primera lectura.

Qué necesitas saber de antemano. Cómo abrir la terminal o la línea de comandos en tu sistema operativo, cómo ejecutar comandos con privilegios de administrador y qué es una dirección IP. Todo lo demás lo explicamos sobre la marcha.

Cuánto tiempo tomará. El recorrido completo con verificaciones tomará entre 40 y 60 minutos. Si solo necesitas limpiar la caché en un lugar concreto, busca el paso correspondiente y resuélvelo en 5 minutos.

Preparación previa: herramientas, accesos y copias de seguridad

Antes de empezar, asegúrate de tener todo lo necesario a mano. La lista es corta, pero cada punto importa: sin privilegios de administrador no podrás limpiar la caché del sistema, y sin la utilidad dig será difícil ver los TTL de los registros.

Herramientas necesarias

  • Terminal con privilegios de administrador. En Linux y macOS es sudo; en Windows es la línea de comandos o PowerShell ejecutados como administrador.
  • Utilidades dig y nslookup. En Linux, dig viene en el paquete dnsutils (Debian y Ubuntu) o bind-utils (Fedora, RHEL). En macOS, dig está instalado por defecto. En Windows existe nslookup, y dig puedes obtenerlo con el paquete BIND o usar el comando de PowerShell Resolve-DnsName.
  • Utilidad curl. Presente en las versiones actuales de Windows 11, macOS y casi todas las distribuciones de Linux de 2026.
  • Navegador. Sirve Chrome, cualquier navegador basado en Chromium o Firefox. Veremos ambas familias.
  • Java Development Kit versión 17, 21 o 25, si planeas hacer el paso sobre la JVM. Si no usas Java, puedes omitir este paso.
  • Acceso al servidor proxy con el que trabajas: dirección, puerto, usuario y contraseña. Vamos a cambiar el proxy para observar el efecto de las cachés.
  • Dominio de prueba. Lo mejor es un dominio cuyo registro A puedas cambiar, o un dominio con respuesta dependiente de la geografía. Si no tienes uno propio, sirve cualquier sitio grande con CDN: esos dominios suelen dar respuestas distintas según la región.

Requisitos del sistema

La guía fue probada en Ubuntu 24.04 y 26.04, Debian 13, Fedora 43, Windows 11 con las actualizaciones de 2026 y macOS 15 o superior. En otros sistemas los comandos pueden variar un poco, pero la lógica es la misma.

Instalación de lo que falte

  1. En Ubuntu o Debian ejecuta sudo apt update && sudo apt install dnsutils curl.
  2. En Fedora ejecuta sudo dnf install bind-utils curl.
  3. En macOS no hace falta instalar nada. Si quieres, instala bind con Homebrew: brew install bind.
  4. En Windows abre PowerShell como administrador y verifica que el comando Resolve-DnsName example.com devuelva un resultado. Con eso basta.

Copias de seguridad

Vamos a editar archivos de configuración: java.security, nscd.conf, archivos en el directorio /etc/systemd/resolved.conf.d y el archivo hosts. Antes de modificar cada archivo, haz una copia. Método universal: sudo cp /ruta/al/archivo /ruta/al/archivo.bak. En Windows simplemente copia el archivo a la misma carpeta con el sufijo .bak desde el explorador.

Atención: limpiar la caché DNS por sí solo es seguro y no rompe el sistema. Pero desactivar sin pensar el servicio systemd-resolved o nscd puede dejarte sin resolución de nombres hasta reiniciar. No desactives servicios a menos que la guía lo indique explícitamente. Solo vamos a limpiar sus cachés y modificar parámetros.

Consejo: crea un archivo de texto a modo de bitácora y anota ahí cada comando y su resultado. En media hora ya no recordarás qué caché limpiaste primero, y la bitácora te ahorrará tiempo al analizar los errores típicos.

Conceptos básicos: cómo un nombre se convierte en dirección y dónde queda atrapado

Para combatir las cachés con seguridad hay que entender cuántas hay y por qué existen. Veamos los términos clave en palabras sencillas.

DNS y resolución

DNS es un directorio distribuido que traduce un nombre legible para humanos como example.com en una dirección IP con la que la red sabe trabajar. El proceso de traducción se llama resolución (del inglés resolve, resolver). Cada vez que un programa quiere conectarse a un sitio, necesita la IP y la pide al resolutor o la toma de la caché.

TTL: tiempo de vida del registro

TTL (Time To Live) es la cantidad de segundos durante los cuales el dueño del dominio permite memorizar la respuesta. Si el TTL es 300, cualquier caché en el camino tiene derecho a guardar la dirección 5 minutos sin volver a preguntar. Valores típicos: desde 60 segundos en servicios que migran con frecuencia hasta 86400 segundos, es decir un día, en recursos estables. Importante: el TTL es un límite superior. La caché puede descartar el registro antes, pero no tiene derecho a guardarlo más tiempo. En la práctica, algunas cachés ignoran el TTL y retienen el registro según sus propias reglas. Precisamente esos casos nos interesan.

La torta de capas de cachés

Lo principal que hay que asimilar: la caché DNS no es un solo lugar. La consulta de un nombre pasa por varias capas, y cada una puede responder desde su propia memoria sin bajar al siguiente nivel. Enumeremos las capas de arriba abajo, desde la aplicación hacia la red.

  1. Caché de la aplicación. El navegador mantiene su propia tabla nombre-dirección. La máquina virtual de Java almacena en caché los resultados de InetAddress. Algunas bibliotecas y frameworks añaden sus propias cachés sobre la del sistema.
  2. Pool de conexiones. Formalmente no es una caché DNS, pero el efecto es el mismo: la aplicación ya abrió una conexión TCP hacia la IP antigua y la reutiliza sin resolver nada. Los navegadores y los clientes HTTP lo hacen constantemente.
  3. Resolutor del sistema y su caché. En Linux moderno suele ser systemd-resolved, escuchando en la dirección 127.0.0.53. En sistemas antiguos y mínimos, nscd (Name Service Cache Daemon) o dnsmasq. En Windows, el servicio DNS Client. En macOS, mDNSResponder.
  4. Archivo hosts. Registros estáticos que se superponen al DNS. No es una caché en sentido estricto, pero es una fuente frecuente de sorpresas.
  5. Caché del router o del servidor DNS local en la red del proveedor. No podemos influir en él, pero debemos tenerlo en cuenta.
  6. Servidor autoritativo del dominio. La fuente de la verdad, a la que la consulta llega solo cuando todas las cachés superiores están vacías o vencidas.

Por qué el proxy no tiene nada que ver aquí

El servidor proxy trabaja a nivel de transporte: recibe tu conexión y abre su propia conexión hacia el destino. La resolución del nombre ocurre antes de ese momento y según sus propias reglas. Si la aplicación resuelve el nombre por sí misma, toma la dirección de la caché de las capas 1–4 y luego decide si ir directamente o a través del proxy. Cambiar el proxy no toca ninguna de esas cachés. Los registros en ellas viven su propia vida, y mientras el TTL no venza o la caché no se limpie forzosamente, seguirás viendo el resultado antiguo.

También existe la situación inversa: al usar un proxy HTTP con el método CONNECT o un proxy SOCKS con resolución remota, el nombre se transmite al proxy y es él quien resuelve. Entonces las cachés locales no participan, pero sí participa la caché del lado del proxy. No analizamos ese escenario en detalle, pero en el paso 5 mostraremos cómo entender rápido dónde ocurrió exactamente la resolución.

Caché negativa

Un término aparte que suele confundir: caché negativa (negative cache). Si el resolutor recibió la respuesta de que el nombre no existe, también lo memorizará. En la JVM las respuestas negativas se almacenan 10 segundos por defecto; en systemd-resolved, según el TTL del registro SOA del dominio. Por eso, si acabas de añadir un dominio y la aplicación insiste en que el nombre no se encuentra, el problema puede ser precisamente la caché negativa.

Paso 1: Diagnóstico — encontramos qué capa retiene la dirección antigua

Objetivo de la etapa: aprender a determinar en unos pocos comandos en qué nivel quedó atrapado el registro, para no limpiar todo a ciegas.

El principio del diagnóstico es simple: preguntamos el mismo dominio en distintas capas y comparamos las respuestas. Si el servidor autoritativo da la dirección nueva, el resolutor del sistema da la nueva y el navegador da la antigua, el culpable es evidente.

Consultamos la fuente autoritativa

  1. Abre la terminal.
  2. Ejecuta dig example.com A +noall +answer, sustituyendo tu dominio. Verás una línea como example.com. 287 IN A 93.184.215.14. El segundo campo es el TTL restante en segundos en tu resolutor. Si el número disminuye en ejecuciones sucesivas, la respuesta viene de la caché.
  3. Ahora evita las cachés locales y pregunta directamente a un resolutor público: dig @1.1.1.1 example.com A +noall +answer. Compara la dirección y el TTL.
  4. Por último, averigua el servidor autoritativo del dominio: dig example.com NS +short. Toma cualquier nombre de la lista y pregúntale: dig @ns1.example-dns.net example.com A +noall +answer. Aquí el TTL siempre es completo y la dirección es la más reciente.

En Windows el equivalente: Resolve-DnsName example.com -Type A para la resolución del sistema y Resolve-DnsName example.com -Type A -Server 1.1.1.1 para evitar la caché local.

Consultamos el resolutor del sistema

  1. En Linux con systemd-resolved ejecuta resolvectl query example.com. Al final de la salida habrá una línea con la fuente del dato: Data from: cache significa que la respuesta se tomó de la caché; Data from: network, que la consulta salió a la red.
  2. Verifica cómo resuelven los programas normales a través de la biblioteca del sistema: getent hosts example.com. Ese es el camino que usan curl sin claves especiales, Python, Go y la mayoría de las utilidades. Si el resultado difiere del de dig, significa que entre ellos hay otra capa: el archivo hosts, nscd u otro orden en /etc/nsswitch.conf.
  3. En Windows ejecuta ipconfig /displaydns | findstr example.com. Si el dominio aparece en la lista, está en la caché del servicio DNS Client.
  4. En macOS ejecuta dscacheutil -q host -a name example.com. La salida mostrará qué entrega exactamente el sistema a las aplicaciones.

Consultamos la aplicación

  1. En Chrome abre la dirección chrome://net-internals/#dns y pulsa el botón Lookup, escribiendo el dominio en el campo de al lado. El resultado mostrará si el registro está en la caché del navegador.
  2. En Firefox abre about:networking#dns. La tabla mostrará todos los nombres en caché, sus direcciones y el tiempo de vida restante en la columna Expires.
  3. Para verificar qué IP usó realmente la aplicación, abre chrome://net-internals/#sockets en Chrome: ahí se ven los sockets abiertos y las direcciones de destino.

Verificación: al final del paso debes tener una tabla de cuatro filas: la dirección del servidor autoritativo, la del resolutor del sistema, la de getent y la del navegador. La discrepancia entre filas contiguas señala la capa donde quedó atrapado el registro.

Posibles problemas

  • dig no está instalado. Vuelve a la sección de preparación e instala el paquete dnsutils o bind-utils. Temporalmente puedes usar nslookup example.com, pero no muestra el TTL.
  • resolvectl informa un error de conexión al bus. Significa que systemd-resolved no está en ejecución y el sistema usa otro resolutor. Revisa el contenido de /etc/resolv.conf: si ahí no está 127.0.0.53, busca nscd o dnsmasq en el paso 2.
  • Las respuestas son iguales en todas partes, pero el sitio igual se comporta de forma extraña. Lo más probable es que la culpa sea del pool de conexiones o de la caché del lado del proxy. Eso lo vemos en el paso 5.

Consejo: la clave +noall +answer de dig elimina la salida sobrante y deja solo la respuesta. Añade un alias a tu perfil de shell, por ejemplo alias d='dig +noall +answer', y el diagnóstico se acelerará al doble.

Paso 2: Limpiamos la caché DNS del sistema en Linux, Windows y macOS

Objetivo de la etapa: vaciar la caché del sistema operativo para que la siguiente consulta de cualquier aplicación salga garantizadamente a la red.

Linux: systemd-resolved

En Ubuntu, Fedora, Debian con configuración por defecto y la mayoría de las distribuciones modernas de 2026, de la resolución se encarga systemd-resolved. Confírmalo con el comando systemctl is-active systemd-resolved: la respuesta active lo confirma.

  1. Mira las estadísticas de la caché antes de limpiarla: resolvectl statistics. En el bloque Cache verás las líneas Current Cache Size, Cache Hits y Cache Misses. Anota el valor de Current Cache Size.
  2. Limpia la caché: sudo resolvectl flush-caches. El comando no muestra nada, es normal.
  3. Repite resolvectl statistics. El valor de Current Cache Size debe quedar en cero.
  4. Limpia también la caché negativa si añadiste un dominio nuevo. No hay un comando aparte: flush-caches limpia todo a la vez, incluidos los registros negativos.
  5. Verifica: resolvectl query example.com debe mostrar al final Data from: network.

Método alternativo si resolvectl no está disponible: sudo systemctl restart systemd-resolved. El reinicio tarda menos de un segundo y también limpia la caché, pero interrumpe por un instante la resolución de todos los programas. En trabajo interactivo es imperceptible, pero en un servidor bajo carga es mejor usar flush-caches.

Linux: nscd

El servicio nscd no solo almacena en caché el DNS, sino también usuarios, grupos y otros datos de /etc/nsswitch.conf. Se encuentra en instalaciones antiguas, en algunas imágenes de servidor y donde lo pusieron a propósito. Verifica su presencia: systemctl is-active nscd.

  1. Limpia solo la tabla de hosts sin tocar lo demás: sudo nscd -i hosts. La clave -i significa invalidate, es decir, invalidar.
  2. Si el comando no está disponible, reinicia el servicio: sudo systemctl restart nscd.
  3. Verifica el resultado con getent hosts example.com. Precisamente getent pasa por nscd, mientras que dig lo evita.

Atención: nscd tiene sus propios ajustes de TTL en el archivo /etc/nscd.conf, y pueden ser mayores que el TTL del registro DNS. La línea positive-time-to-live hosts 3600 significa que nscd retendrá la dirección una hora, aunque el dueño del dominio haya puesto un TTL de 60 segundos. Esta es una de las causas más frecuentes de que en los servidores la dirección antigua viva más de lo esperado. Volveremos a esto en el paso 6.

Linux: dnsmasq

dnsmasq suele actuar como resolutor caché local en routers, en entornos de contenedores y en versiones antiguas de NetworkManager. Señal: en /etc/resolv.conf aparece la dirección 127.0.0.1 o 127.0.1.1, y el comando pidof dnsmasq devuelve el número del proceso.

  1. Limpia la caché con una señal: sudo kill -HUP $(pidof dnsmasq). La señal HUP obliga a dnsmasq a releer la configuración y limpiar la caché.
  2. O reinicia el servicio: sudo systemctl restart dnsmasq.

Windows 11

  1. Pulsa la tecla Windows, escribe cmd, haz clic derecho sobre Símbolo del sistema y elige Ejecutar como administrador.
  2. Ejecuta ipconfig /displaydns para ver el contenido de la caché. La lista puede ser larga: desplázate o filtra con findstr.
  3. Limpia la caché: ipconfig /flushdns. Deberías ver el mensaje Se vació correctamente la caché del solucionador de DNS.
  4. Alternativa en PowerShell: Clear-DnsClientCache para limpiar y Get-DnsClientCache para ver. La variante de PowerShell es más cómoda para scripts.

Si el comando informa que no se pudo vaciar la caché, verifica si el servicio DNS Client está iniciado: Get-Service Dnscache. El estado debe ser Running. Si el servicio está detenido, Windows resuelve sin caché y el problema definitivamente no está aquí.

macOS

  1. Abre Terminal: Finder, Aplicaciones, Utilidades, Terminal. O pulsa Cmd+Espacio y escribe Terminal.
  2. Ejecuta sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder. Introduce la contraseña de administrador cuando el sistema la pida. Ambas partes son necesarias: la primera limpia la caché del servicio de directorio, la segunda obliga a mDNSResponder a limpiar su propia caché.
  3. No habrá salida. Verifica el resultado: dscacheutil -q host -a name example.com debe devolver la dirección nueva.

Verificación: después de limpiar en cualquier SO, repite el diagnóstico del paso 1. El resolutor del sistema debe entregar la dirección que coincide con la respuesta del servidor autoritativo, y el TTL en la primera consulta debe ser el máximo para ese registro.

Posibles problemas

  • Después de limpiar, la dirección sigue siendo la antigua. Revisa el archivo hosts: en Linux y macOS es /etc/hosts; en Windows, C:\Windows\System32\drivers\etc\hosts. Un registro ahí se superpone al DNS por completo. Revisa también la caché del resolutor superior: si dig @1.1.1.1 también da la dirección antigua, los cambios del dueño del dominio aún no se han propagado y habrá que esperar el TTL completo.
  • resolvectl flush-caches funcionó, pero el navegador muestra lo antiguo. Es esperable: el navegador no pregunta al sistema hasta que vence su propia caché. Pasa al paso 3.

Consejo: en systemd-resolved existe el parámetro Cache=no-negative, que desactiva el almacenamiento en caché de respuestas negativas. Para desarrolladores que crean dominios nuevos con frecuencia en entornos de prueba, esto salva de infinitos errores de «nombre no encontrado» justo después de publicar el registro.

Paso 3: Limpiamos la caché DNS del navegador y el pool de conexiones

Objetivo de la etapa: hacer que el navegador olvide las direcciones antiguas y cierre las conexiones ya abiertas hacia el servidor antiguo, para que la nueva consulta pase por la cadena de resolución y el proxy actuales.

El navegador es la capa más traicionera. Almacena direcciones en caché independientemente del sistema, mantiene conexiones abiertas por velocidad e incluso puede resolver nombres con su propio cliente DNS-over-HTTPS, evitando por completo la configuración del SO.

Chrome y navegadores basados en Chromium

  1. En la barra de direcciones escribe chrome://net-internals/#dns y pulsa Enter.
  2. Pulsa el botón Clear host cache. No habrá confirmación visual, el botón simplemente funciona.
  3. Ve a la pestaña chrome://net-internals/#sockets.
  4. Pulsa Flush socket pools. Este botón cierra todas las conexiones abiertas. Sin él, el navegador seguirá enviando consultas por el canal ya establecido hacia la IP antigua, y limpiar el DNS no servirá de nada.
  5. Ahí mismo pulsa Close idle sockets para mayor seguridad.
  6. Verifica si está activado el DNS seguro: abre chrome://settings/security y busca la opción Usar un servidor DNS seguro. Si está activada y se indica un proveedor concreto, Chrome resuelve a través de él y ni la caché del sistema ni los servidores DNS del sistema participan en absoluto. Para pruebas donde importa la resolución del sistema, cambia temporalmente la opción a la variante con el proveedor actual o desactívala.
  7. Abre el sitio de prueba de nuevo. Mejor en una pestaña nueva.

Las direcciones mencionadas funcionan en Chrome, Edge, Yandex Browser, Opera y otras compilaciones de Chromium en versiones actuales de 2026. En Edge la dirección empieza con edge:// en lugar de chrome://; lo demás coincide.

Firefox

  1. Escribe en la barra de direcciones about:networking#dns.
  2. Pulsa el botón Clear DNS Cache en la parte superior de la página. La tabla de registros se vaciará de inmediato.
  3. Ve a la pestaña HTTP de la misma página about:networking y mira la lista de conexiones activas. No hay un botón aparte para cerrarlas, así que para limpiar el pool de conexiones reinicia Firefox o pasa al modo sin conexión y vuelve: menú, Trabajar sin conexión, luego quita la marca.
  4. Para controlar el tiempo de vida de la caché abre about:config, confirma la advertencia y busca el parámetro network.dnsCacheExpiration. El valor por defecto es 60 segundos. Para depurar pon 0: Firefox dejará de almacenar nombres en caché. No olvides devolver el valor después del trabajo.
  5. El parámetro network.dnsCacheEntries define el número máximo de registros, por defecto 400. No tiene sentido reducirlo, pero es útil conocerlo.
  6. Revisa network.trr.mode: un valor de 2 o 3 significa que Firefox usa DNS-over-HTTPS y el resolutor del sistema se ignora parcial o totalmente. Para pruebas limpias del resolutor del sistema pon 0 o 5.

Perfil y modo incógnito como alternativa

Si necesitas verificar un sitio «desde cero» rápidamente, abre una ventana de incógnito o una ventana privada. En Chrome la caché DNS del incógnito es compartida con la ventana principal, así que este método no garantiza una resolución limpia; en Firefox la ventana privada tiene su propia caché. La opción más confiable para ambas familias es un perfil de navegador separado creado para pruebas. El perfil arranca con cachés vacías y pool de conexiones vacío.

Verificación: después de limpiar, abre chrome://net-internals/#dns y pulsa Lookup para el dominio de prueba: la dirección debe coincidir con la respuesta del servidor autoritativo del paso 1. En Firefox la tabla de about:networking#dns debe mostrar un registro nuevo con el TTL completo.

Posibles problemas

  • Se pulsó Clear host cache pero el sitio carga desde el servidor antiguo. Casi siempre se olvidó Flush socket pools. La conexión ya está abierta y no necesita DNS.
  • El sitio usa HTTP/3 o QUIC. Esas conexiones pueden sobrevivir a la limpieza de los pools. Desactiva QUIC temporalmente en chrome://flags/#enable-quic, reinicia el navegador y repite la prueba.
  • Una extensión o un script PAC controla el proxy. La función dnsResolve en los archivos PAC usa la caché del navegador. Si las reglas del proxy dependen de la IP del destino, una dirección antigua llevará a la ruta antigua. Limpia la caché y recarga el PAC desde la configuración de proxy del sistema.

Consejo: añade las páginas chrome://net-internals/#dns y chrome://net-internals/#sockets a los marcadores de la barra. Dos clics en lugar de teclear la dirección ahorran bastante tiempo con cambios frecuentes de proxy.

Paso 4: Controlamos la caché DNS en la JVM y en aplicaciones Java

Objetivo de la etapa: entender las reglas de caché de la máquina virtual de Java, limpiar la caché en una aplicación en ejecución y configurar el TTL para que el cambio de proxy o de dirección se capte sin reiniciar.

Las aplicaciones Java son conocidas por «pegarse» a la IP antigua. La causa está en la clase InetAddress, que almacena los resultados de resolución aparte del sistema. Las reglas son: las respuestas exitosas se guardan 30 segundos; si el gestor de seguridad está activado, indefinidamente; y las respuestas negativas se guardan 10 segundos. En Java 17, 21 y 25 el gestor de seguridad está desactivado y en las versiones nuevas fue eliminado, así que por defecto tienes 30 segundos. Pero muchas aplicaciones de servidor cambian estos parámetros en la configuración, y ahí sí aparecen valores de horas e incluso infinito.

Vemos la configuración actual

  1. Encuentra el archivo java.security. En JDK 17 y posteriores está en el directorio $JAVA_HOME/conf/security/java.security. En Windows la ruta es del tipo C:\Program Files\Java\jdk-21\conf\security\java.security.
  2. Abre el archivo y busca las líneas networkaddress.cache.ttl y networkaddress.cache.negative.ttl. Por defecto la primera está comentada y la segunda vale 10.
  3. Revisa los parámetros de arranque de la aplicación: busca en los scripts y unidades de systemd las claves -Dsun.net.inetaddr.ttl y -Dsun.net.inetaddr.negative.ttl. Son propiedades del sistema que actúan como variante de reserva si las propiedades de seguridad no están definidas.
  4. Revisa el código de la aplicación en busca de llamadas a Security.setProperty con esas claves: el código puede sobrescribir todo lo que configures desde fuera.

Configuramos el TTL

  1. Haz una copia de seguridad: sudo cp $JAVA_HOME/conf/security/java.security $JAVA_HOME/conf/security/java.security.bak.
  2. Abre el archivo en un editor con privilegios de administrador y descomenta o añade la línea networkaddress.cache.ttl=10. Un valor de 10 segundos es un compromiso razonable para aplicaciones que deben reaccionar rápido al cambio de direcciones. El valor 0 desactiva la caché por completo: cada resolución va al sistema. El valor -1 activa el almacenamiento indefinido y no sirve para nuestras tareas.
  3. Si hace falta, reduce la caché negativa: networkaddress.cache.negative.ttl=0. Útil en entornos donde los dominios aparecen al vuelo.
  4. Si no quieres tocar el archivo global del JDK, crea tu propio archivo, por ejemplo /etc/myapp/java.security.override, con las dos líneas de parámetros, y conéctalo al arrancar con la clave -Djava.security.properties=/etc/myapp/java.security.override. Esto sobrescribirá solo las propiedades indicadas; las demás quedarán estándar.
  5. La variante más rápida sin editar archivos: añade a los parámetros de arranque -Dsun.net.inetaddr.ttl=10 -Dsun.net.inetaddr.negative.ttl=0. Recuerda que estas propiedades ceden prioridad a las de java.security si están definidas explícitamente.
  6. Reinicia la aplicación para que los nuevos parámetros entren en vigor.

Atención: poner el TTL en 0 en un servicio con alta carga aumenta bruscamente el número de consultas DNS: cada conexión nueva resolverá el nombre. Para sistemas en producción elige 10–60 segundos; deja el valor cero para entornos de depuración.

Limpiamos la caché sin reiniciar

No hay un método público para limpiar la caché de InetAddress en el JDK. Sin embargo, existen enfoques que funcionan.

  • Esperar a que venza el TTL. Con los 30 segundos estándar es más rápido que cualquier manipulación. Verifica que nadie haya puesto -1.
  • Usar un resolutor propio. A partir de Java 18 existe la interfaz InetAddressResolverProvider, mediante la cual la aplicación puede conectar su propia implementación de resolución con cualquier lógica de caché y un método explícito de limpieza. Es un camino avanzado para quienes controlan el código.
  • Verificar la dirección con JShell. Para diagnosticar, ejecuta jshell y ejecuta InetAddress.getByName("example.com"). Así verás qué dirección entrega exactamente la JVM con la configuración actual, independientemente del sistema.

Pools de conexiones en Java

Igual que en el navegador, los clientes Java tienen pools: HttpClient de la biblioteca estándar, Apache HttpClient, OkHttp, drivers de bases de datos. Incluso después de limpiar el DNS, la conexión hacia la IP antigua permanecerá en el pool hasta que se cierre por el timeout de inactividad. Si la aplicación debe cambiar a la nueva dirección de inmediato, configura en el pool un timeout de inactividad corto o invoca el cierre del pool desde un endpoint administrativo, si existe.

Verificación: ejecuta la aplicación con los nuevos parámetros, cambia el registro A del dominio de prueba o reconfigura hosts, espera el TTL indicado más un par de segundos y confirma mediante logs o jshell que la aplicación obtuvo la nueva dirección.

Consejo: en contenedores basados en imágenes Eclipse Temurin y similares, el archivo java.security está en la ruta estándar, pero reconstruir la imagen por dos líneas es incómodo. Usa la variable de entorno JAVA_TOOL_OPTIONS con las claves -D necesarias: la JVM las captará automáticamente al arrancar sin modificar el comando de inicio.

Paso 5: Entendemos las cachés en otros runtimes, utilidades y del lado del proxy

Objetivo de la etapa: cubrir los lugares restantes donde puede esconderse la dirección antigua: bibliotecas de Python, Node.js y Go, la utilidad curl, servidores web, y además entender cuándo la resolución no ocurre en tu máquina sino en el proxy.

Python, Node.js, Go

Buena noticia: las bibliotecas estándar de estos lenguajes no tienen caché DNS propia. Python a través del módulo socket, Node.js a través de dns.lookup y Go a través del paquete net recurren por defecto al resolutor del sistema mediante la función getaddrinfo. Es decir, para ellos basta el paso 2. Hay matices.

  • Node.js. Algunas bibliotecas, como cacheable-lookup, que usan clientes HTTP populares, añaden su propia caché. Búscala en las dependencias del proyecto y configura el parámetro maxTtl. Además, en Node.js existe la clase dns.Resolver, que consulta servidores DNS directamente evitando el resolutor del sistema: entonces la caché del sistema no participa, pero getent tampoco te ayudará en el diagnóstico.
  • Go. Al compilar con CGO_ENABLED=0, Go usa su propio resolutor puro, que lee /etc/resolv.conf y /etc/hosts, pero no recurre a nscd ni a systemd-resolved a través de NSS. No tiene caché, pero http.Transport mantiene un pool de conexiones keep-alive. Para forzar la reconexión, invoca CloseIdleConnections.
  • Python. La biblioteca requests con el adaptador por defecto reutiliza conexiones dentro de la sesión. Crea una sesión nueva después de cambiar el proxy o cierra la antigua con el método close.

curl

curl tiene claves que ayudan a probar sin la influencia de las cachés.

  1. curl -v https://example.com/ — en la salida detallada, la línea Trying 93.184.215.14:443 mostrará a qué IP se conecta realmente.
  2. curl --resolve example.com:443:203.0.113.10 https://example.com/ — sustituye la dirección necesaria para el nombre, evitando por completo el DNS. Es indispensable para verificar un servidor nuevo antes de cambiar el registro.
  3. curl --dns-servers 1.1.1.1 https://example.com/ — obliga a resolver a través del servidor indicado, evitando la caché del sistema. Solo funciona si curl está compilado con la biblioteca c-ares; verifica en la salida de curl -V si aparece la palabra AsynchDNS.

nginx y otros servidores web

nginx resuelve los nombres en la directiva proxy_pass una sola vez al arrancar y guarda la dirección para siempre si el nombre está escrito de forma estática. Para que las direcciones se actualicen, define resolver 127.0.0.53 valid=30s; en el bloque http o server y usa una variable en proxy_pass: entonces nginx volverá a resolver el nombre cada 30 segundos. Mecanismos similares existen en HAProxy y Envoy. Si cambiaste la dirección del backend y nginx sigue yendo a la antigua, recarga la configuración: sudo nginx -s reload.

Dónde ocurrió realmente la resolución: localmente o en el proxy

Este punto conecta nuestra guía con el tema de la resolución remota, sin profundizar en él. Una forma rápida de entender quién resolvió el nombre es mirar la salida detallada del cliente.

  1. Ejecuta curl -v -x http://user:pass@proxy.example:8080 https://example.com/. Si en la salida ves la línea CONNECT example.com:443 HTTP/1.1 y no hay una línea con el intento de conexión a la IP del sitio destino, el nombre se envió al proxy como texto y lo resolvió el proxy. Tus cachés locales no participaron aquí, pero sí pudo actuar la caché del lado del proxy o de su resolutor.
  2. Ejecuta curl -v -x socks5://user:pass@proxy.example:1080 https://example.com/. En este caso curl resuelve el nombre localmente y verás la IP del destino en la salida. Aquí tus cachés de los pasos 2–4 juegan su papel por completo.
  3. El esquema socks5h transmite el nombre al proxy. Los detalles y las consecuencias para la privacidad están desarrollados en un artículo aparte sobre DNS a través de proxy; para nuestra tarea basta recordar la regla: si el nombre se resuelve en el proxy, lo que hay que hacer no es limpiar las cachés locales, sino esperar el TTL del lado del proxy o cambiar de servidor proxy.

Verificación: para cada herramienta que uses debes poder decir dónde ocurre la resolución y si la herramienta tiene caché o pool propios. Anótalo en tu bitácora en forma de tabla: herramienta, lugar de resolución, presencia de caché, comando de limpieza.

Consejo: al cambiar el proxy en servicios de proxy móvil, la IP del nodo de salida puede cambiar por horario o por solicitud mediante un enlace de cambio de IP. La caché DNS de tu lado no se limpia por eso. Si estás comprobando cómo reacciona el sitio a distintas direcciones de salida, cierra siempre el pool de conexiones después de cada cambio, porque la conexión antigua seguirá yendo por el canal anterior.

Paso 6: Configuramos el TTL y automatizamos la limpieza

Objetivo de la etapa: hacer que las cachés no estorben tu trabajo de forma constante: configurar límites razonables de almacenamiento de registros y preparar un script que limpie todas las capas con un solo comando.

Limitamos la caché de systemd-resolved

  1. Crea el directorio de sobrescrituras si no existe: sudo mkdir -p /etc/systemd/resolved.conf.d.
  2. Crea el archivo /etc/systemd/resolved.conf.d/cache.conf con el contenido: la línea [Resolve], luego Cache=yes, luego CacheFromLocalhost=no. Si quieres desactivar la caché por completo durante la depuración, sustituye la primera directiva por Cache=no.
  3. Reinicia el servicio: sudo systemctl restart systemd-resolved.
  4. Verifica que se aplicó: resolvectl status mostrará los parámetros actuales. No hay un parámetro aparte de TTL máximo en systemd-resolved; el servicio respeta el TTL de los registros, pero no por encima de un techo interno. Para la mayoría de las tareas esto es suficiente.

Limitamos la caché de nscd

  1. Haz una copia de seguridad: sudo cp /etc/nscd.conf /etc/nscd.conf.bak.
  2. Abre /etc/nscd.conf y busca el bloque hosts. Establece positive-time-to-live hosts 60 y negative-time-to-live hosts 5. Esto limitará el almacenamiento de direcciones a un minuto y el de errores a cinco segundos.
  3. Si necesitas nscd solo para usuarios y grupos, pero no para DNS, pon enable-cache hosts no. Entonces la resolución de nombres irá directamente al resolutor del sistema.
  4. Reinicia el servicio: sudo systemctl restart nscd.

Script de limpieza completa para Linux

Crea el archivo ~/bin/dnsflush.sh y dale permisos de ejecución con chmod +x ~/bin/dnsflush.sh. Contenido del script línea por línea:

  1. La primera línea declara el intérprete: #!/usr/bin/env bash.
  2. systemctl is-active --quiet systemd-resolved && sudo resolvectl flush-caches && echo "resolved: ok"
  3. systemctl is-active --quiet nscd && sudo nscd -i hosts && echo "nscd: ok"
  4. pidof dnsmasq >/dev/null && sudo kill -HUP $(pidof dnsmasq) && echo "dnsmasq: ok"
  5. resolvectl statistics 2>/dev/null | grep -i "Current Cache Size"

El script verifica qué servicios están activos y limpia solo esos. Ejecútalo después de cada cambio de proxy o de dirección.

Script para Windows

Crea el archivo dnsflush.ps1 con dos líneas: Clear-DnsClientCache y Get-DnsClientCache | Measure-Object | Select-Object -ExpandProperty Count. La segunda línea mostrará el número de registros después de la limpieza, que debe ser cero o cercano a cero. Ejecútalo desde PowerShell como administrador. Si el sistema prohíbe ejecutar scripts, habilítalo para el usuario actual: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned.

Script para macOS

Crea el archivo dnsflush.sh con la línea sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder; echo "macOS DNS cache flushed". Dale permisos de ejecución con chmod y ejecútalo desde Terminal.

Perfil de navegador de prueba con la caché desactivada

Para Chrome crea un acceso directo de arranque con los parámetros --user-data-dir=/tmp/chrome-test --host-resolver-rules="MAP example.com 203.0.113.10". La primera clave crea un perfil limpio aparte; la segunda asocia de forma fija el nombre y la dirección durante la sesión, lo cual es cómodo al probar un servidor nuevo. Para Firefox crea un perfil aparte desde about:profiles y en él pon network.dnsCacheExpiration en 0.

Verificación: ejecuta tu script de limpieza y enseguida ejecuta resolvectl query example.com o el equivalente para tu SO. La fuente del dato debe ser network y el número de registros en las estadísticas de caché debe ser cero.

Consejo: si cambias de proxy con frecuencia en una misma sesión de trabajo, asigna el script de limpieza a una tecla rápida desde la configuración del entorno de escritorio. Una pulsación en lugar de tres comandos reduce notablemente el riesgo de olvidar alguna capa.

Verificación del resultado: lista de comprobación y escenario de prueba completa

Hagamos la prueba final que confirmará que controlas todas las capas. Toma unos 10 minutos.

Lista de comprobación

  • Sabes qué resolutor del sistema se usa en tu máquina y puedes limpiar su caché con un solo comando.
  • Puedes ver el TTL de un registro con dig o Resolve-DnsName y entiendes de dónde viene la respuesta: de la caché o de la red.
  • Limpias la caché DNS y el pool de conexiones del navegador, y sabes que sin lo segundo lo primero no sirve.
  • Tus aplicaciones Java arrancan con networkaddress.cache.ttl definido explícitamente, no con la configuración por defecto.
  • Tienes un script de limpieza completa para tu SO.
  • Puedes determinar con un solo comando curl si el nombre se resuelve localmente o en el proxy.

Escenario de prueba completa

  1. Añade al archivo hosts una línea con el dominio de prueba y una dirección deliberadamente incorrecta, por ejemplo 203.0.113.99. Esto simula la dirección «antigua».
  2. Abre el dominio en el navegador y confirma que la conexión no se establece o va a la dirección sustituta. Verifica en chrome://net-internals/#dns que el registro se almacenó en caché.
  3. Elimina la línea del archivo hosts.
  4. Actualiza la página sin limpiar nada. Esperado: el navegador sigue usando la dirección sustituta. Esta es la demostración del problema.
  5. Ejecuta el script de limpieza de la caché del sistema.
  6. Actualiza la página otra vez. Esperado: sigue la dirección antigua, porque la caché del navegador no se tocó.
  7. Ejecuta Clear host cache y Flush socket pools.
  8. Actualiza la página. Esperado: el sitio se abre desde la dirección correcta. Esto confirma que entiendes el orden de las capas.
  9. Repite los puntos 1–8 con jshell en lugar del navegador si trabajas con Java, observando el efecto del TTL.

Indicadores de éxito

Cada capa se comporta de forma predecible, puedes anticipar qué resultado dará la siguiente consulta y ya no surgen sorpresas tras cambiar el proxy. Si en algún paso el resultado difiere de lo esperado, vuelve a la sección de diagnóstico y encuentra la capa que omitiste.

Errores típicos y soluciones

Limpié la caché del sistema, pero el navegador sigue mostrando el sitio antiguo

Causa: el navegador tiene su propia caché DNS y conexiones abiertas. Solución: Clear host cache más Flush socket pools en Chrome; Clear DNS Cache más reinicio en Firefox. Verifica si el DNS-over-HTTPS está activado en el navegador: entonces el resolutor del sistema no participa en absoluto.

La aplicación Java retiene la IP antigua durante horas

Causa: en java.security o en los parámetros de arranque está networkaddress.cache.ttl=-1, o la aplicación lo define en el código. Solución: encuentra y cambia el valor a 10–60 segundos, reinicia la aplicación. Revisa también el pool del cliente HTTP: las conexiones hacia la IP antigua viven hasta el timeout de inactividad.

El comando resolvectl no se encuentra o no se conecta

Causa: el sistema no usa systemd-resolved. Solución: mira /etc/resolv.conf. La dirección 127.0.0.1 apunta a dnsmasq u otra caché local; direcciones del proveedor significan que no hay caché local. Actúa según el subapartado correspondiente del paso 2.

Un dominio nuevo no resuelve aunque el registro ya está publicado

Causa: la caché negativa memorizó la respuesta de que el nombre no existe. Solución: limpia la caché del sistema; en systemd-resolved añade Cache=no-negative; en la JVM pon networkaddress.cache.negative.ttl=0. Verifica que el registro sea visible desde el servidor autoritativo con dig indicando el servidor.

getent muestra una dirección y dig otra

Causa: entre ellos hay un archivo hosts o nscd con su propio TTL. Solución: revisa /etc/hosts y /etc/nsswitch.conf, limpia nscd con nscd -i hosts y, si hace falta, limita positive-time-to-live en nscd.conf.

Después de cambiar la IP en un proxy móvil, el sitio ve la dirección de salida anterior

Causa: no es DNS, sino una conexión viva: el navegador o el cliente sigue trabajando por el canal TCP ya abierto a través de la ruta anterior. Solución: cierra el pool de conexiones, desactiva QUIC durante la prueba y, para scripts, crea una sesión nueva después de cada cambio.

curl a través de socks5 muestra la IP local del destino, pero a través de un proxy http no

Causa: con el esquema socks5 sin el sufijo h el nombre se resuelve localmente; con HTTP CONNECT se resuelve en el proxy. Es un comportamiento normal, no un error. Solución: entender dónde ocurre la resolución y limpiar la caché correspondiente; los detalles están en el artículo aparte sobre resolución remota.

Windows dice que no se pudo vaciar la caché

Causa: la línea de comandos se abrió sin privilegios de administrador o el servicio Dnscache está detenido. Solución: reinicia la terminal como administrador; revisa el estado del servicio con Get-Service Dnscache y, si hace falta, inícialo.

Funciones adicionales para usuarios avanzados

Observación de la caché en tiempo real

En Linux el comando sudo resolvectl monitor muestra todas las consultas DNS que pasan por systemd-resolved, con una marca de si la consulta salió a la red. Ejecútalo en otra ventana y cambia el proxy en el navegador: verás con tus propios ojos qué consultas hace el navegador y cuáles toma de su caché sin llegar al sistema. Es la forma más clara de entender la naturaleza por capas de las cachés.

Espacios de nombres de red para pruebas limpias

Con ip netns puedes crear un espacio de red aislado con su propio resolv.conf y sin cachés compartidas. Ejecutar el navegador o curl dentro de ese espacio garantiza que ninguna caché del sistema influya en el resultado. La configuración requiere experiencia, pero para pruebas comparativas regulares a través de distintos proxies se amortiza con creces.

Registro de resolución en la JVM

La clave -Djava.net.preferIPv4Stack=true simplifica el diagnóstico al quitar IPv6 de la ecuación, y el flag -Xlog:net en versiones recientes del JDK ayuda a ver eventos de red. Para un análisis más profundo usa Java Flight Recorder con eventos de entrada/salida de red.

Resolutor caché propio

Si administras un servidor y quieres controlar el TTL de forma centralizada para todas las aplicaciones, levanta Unbound o Knot Resolver con los parámetros cache-max-ttl y cache-min-ttl. Entonces las aplicaciones del sistema recibirán un comportamiento predecible independientemente de lo que haya definido el dueño del dominio. Ten en cuenta que bajar el TTL en contra de la voluntad del dueño del dominio es una práctica discutible; aplícala solo en entornos de prueba.

Limpieza automática al cambiar de proxy

Si cambias de proxy con un script, añade la llamada al script de limpieza del paso 6 al final del procedimiento de cambio. Para el navegador es más difícil automatizar la pulsación de botones: usa perfiles separados para cada configuración o arranca el navegador con el flag --host-resolver-rules, que hace predecible la caché.

FAQ: preguntas frecuentes sobre la caché DNS y su limpieza

¿Hay que reiniciar la computadora después de limpiar la caché?

No. Todos los comandos de la guía actúan de inmediato. Reiniciar también limpia las cachés, pero es el método más lento, y no ayudará si el problema está en el TTL del lado de nscd o en la JVM con caché indefinida: después de reiniciar volverán a almacenar la primera respuesta.

¿Cómo saber qué TTL tiene mi dominio?

Ejecuta dig indicando el servidor autoritativo: dig @ns1.tuservidor dominio A +noall +answer. El segundo campo de la respuesta es el TTL completo. La respuesta de un resolutor común mostrará el tiempo restante, que disminuye con cada segundo.

¿Puede perjudicar al sistema limpiar la caché?

No. La caché es un almacenamiento temporal; el sistema la llenará de nuevo. El único efecto secundario es una breve ralentización del primer acceso a cada sitio. Lo único dañino puede ser desactivar por completo los servicios de resolución, cosa que no hacemos.

¿Por qué en Chrome no hay un TTL aparte para la caché DNS como en Firefox?

Chrome respeta el TTL del registro, pero no por encima de 60 segundos para respuestas positivas, y no permite cambiarlo desde la configuración. Solo se puede controlar limpiándola desde net-internals o con flags de arranque como --host-resolver-rules.

¿Cómo limpiar la caché DNS en un contenedor Docker?

Por defecto el contenedor no tiene un resolutor caché propio y recurre al DNS integrado de Docker en la dirección 127.0.0.11 o a los servidores de resolv.conf del host. El DNS integrado de Docker almacena poco en caché. Si la aplicación dentro del contenedor es Java, configura la JVM. Si hay que limpiar la caché del host, hazlo en el host.

¿Qué hacer si el TTL del dominio es de un día y necesito verificar la nueva dirección ahora?

No esperes: usa curl con la clave --resolve o Chrome con el flag --host-resolver-rules, o añade temporalmente un registro en hosts. Las tres formas evitan el DNS y permiten probar el servidor nuevo de inmediato. No olvides quitar el registro de hosts después de la prueba.

¿Afecta el cambio de proxy a la caché DNS al menos de alguna forma?

Directamente, no. Ninguna de las cachés analizadas monitorea la configuración del proxy. La única influencia indirecta: si la resolución se hace en el proxy, con un proxy nuevo obtienes también su caché, por lo que la respuesta puede diferir. Pero las cachés locales permanecen como estaban.

¿Cómo entender que el registro antiguo lo retiene el proveedor y no yo?

Pregunta directamente a un resolutor público: dig indicando el servidor 1.1.1.1 o 8.8.8.8. Si la respuesta coincide con el servidor autoritativo y el resolutor del sistema da otra, el problema está en tu máquina. Si los resolutores públicos también dan la dirección antigua, los cambios aún no se han propagado y queda esperar el TTL.

¿Hay que cambiar algo en el smartphone al probar con proxies móviles?

En esta guía el smartphone como fuente de tráfico del proxy no se analiza; trabajas con él como nodo remoto. Pero en el dispositivo desde el que pruebas actúan todas las capas descritas. Si pruebas desde el teléfono, activa el modo avión unos segundos: eso limpia la caché DNS del sistema en iOS y Android; reinicia también el navegador del teléfono.

Conclusión

Resumamos. Entendiste que la resolución de nombres y el funcionamiento del proxy son capas distintas, y que cambiar el proxy no tiene por qué cambiar el resultado de la resolución. Aprendiste a diagnosticar el problema con cuatro comandos, comparando las respuestas del servidor autoritativo, del resolutor del sistema, de la llamada de biblioteca y de la aplicación. Sabes limpiar la caché de systemd-resolved, nscd, dnsmasq, del servicio DNS Client en Windows y de mDNSResponder en macOS. Limpias la caché y el pool de conexiones del navegador, controlas el TTL en la JVM mediante java.security y propiedades del sistema, y sabes dónde se esconden las cachés en curl, nginx y las bibliotecas populares. Y lo más importante: tienes un script que hace todo esto con un solo comando.

Qué hacer a continuación. Adopta la costumbre: cambiaste el proxy o la dirección, ejecutaste la limpieza, cerraste el pool de conexiones y verificaste con dig. En una semana se volverá automático y el problema «cambiar el proxy no cambia la resolución» dejará de existir para ti.

Hacia dónde desarrollarte. El siguiente paso lógico es el artículo sobre DNS a través de proxy y resolución remota: ahí aprenderás a hacer que el nombre se resuelva del lado del proxy y qué consecuencias trae. Después vale la pena estudiar el funcionamiento de DNS-over-HTTPS en navegadores y sistemas, porque este mecanismo intercepta cada vez más la resolución de la mano del sistema operativo. Y por último, dominar los espacios de nombres de red en Linux te dará una herramienta para pruebas comparativas absolutamente limpias. ¡Mucha suerte, y que tus registros siempre se actualicen a tiempo!