Configura NodeLocal DNSCache

En esta página, se explica cómo configurar NodeLocal DNSCache en un clúster de Google Kubernetes Engine (GKE). NodeLocal DNSCache mejora la latencia de búsqueda de DNS, hace que la búsqueda de DNS sea más coherente y reduce la cantidad de consultas de DNS a kube-dns mediante la ejecución de una caché de DNS en cada nodo del clúster.

Para obtener una descripción general de cómo funciona el descubrimiento de servicios y el DNS administrado en GKE, consulta Descubrimiento de servicios y DNS.

Descripción general

NodeLocal DNSCache es un complemento opcional de GKE que puedes ejecutar además de kube-dns. NodeLocal DNSCache se implementa como un DaemonSet que ejecuta una caché de DNS en cada nodo de tu clúster. Cuando un pod realiza una solicitud de DNS, la solicitud va a la caché de DNS que se ejecuta en el mismo nodo que el pod. Si la caché no puede resolver la solicitud de DNS, la caché reenvía la solicitud a uno de los siguientes:

  • Cloud DNS para consultas de nombre de host externo (el servidor de metadatos local que se ejecuta en el mismo nodo que el pod desde el que se originó la consulta reenvía estas consultas a Cloud DNS)
  • kube-dns para todas las demás consultas de DNS Los Pods node-local-dns usan el servicio kube-dns-upstream para comunicarse con los Pods kube-dns.

Un diagrama de la ruta de acceso de una solicitud de DNS, como se describe en el párrafo anterior

No es necesario modificar los pods para usar NodeLocal DNSCache. NodeLocal DNSCache consume recursos de procesamiento en cada nodo de tu clúster.

Beneficios de NodeLocal DNSCache

  • Tiempo de búsqueda de DNS promedio reducido
  • Las conexiones desde los pods a su caché local no crean entradas de tabla conntrack. Esto evita las conexiones caídas y rechazadas causadas por el agotamiento de la tabla de Conntrack y las condiciones de carrera.

Detalles

  • NodeLocal DNSCache requiere GKE versión 1.15 o superior.
  • Las conexiones entre la caché de DNS local y kube-dns usan TCP en lugar de UDP para mejorar la confiabilidad.
  • Las consultas de DNS para URL externas (URL que no hacen referencia a recursos de clúster) se reenvían directamente al servidor de metadatos local de Cloud DNS, sin pasar por kube-dns.
  • Las cachés de DNS locales recogen automáticamente los dominios de stub y los servidores de nombres ascendentes que se especifican en kube-dns ConfigMap.

  • Los Registros DNS se almacenan en caché para lo siguiente:

    • El TTL del registro, o 30 segundos si el TTL es más de 30 segundos
    • 5 segundos si la respuesta de DNS es NXDOMAIN
  • Los Pods de NodeLocal DNSCache escuchan en los puertos 53, 9253 y 8080 en los nodos. La ejecución de cualquier otro Pod de HostNetwork mediante los puertos anteriores o la configuración de hostPorts con los puertos anteriores hará que NodeLocal DNSCache falle y genere errores de DNS.

Habilita NodeLocal DNSCache

Puedes habilitar NodeLocal DNSCache en un clúster existente o cuando creas uno nuevo. Habilitar NodeLocal DNSCache en un clúster existente es un proceso perjudicial, se recrean todos los nodos del clúster que ejecutan GKE 1.15 y versiones posteriores. Los nodos se vuelven a crear según el proceso de actualización de nodos de GKE.

gcloud

Habilita NodeLocal DNSCache en un clúster nuevo

Para habilitar NodeLocal DNSCache en un clúster nuevo, usa la marca --addons NodeLocalDNS:

gcloud container clusters create cluster-name \
  --zone compute-zone \
  --cluster-version cluster-version \
  --addons NodeLocalDNS

Reemplaza los siguientes elementos:

  • cluster-name: Es el nombre del clúster nuevo.
  • compute-zone: Es la zona del clúster.
  • cluster-version: Es la versión del clúster (1.15 o superior).

Habilita NodeLocal DNSCache en un clúster existente

Para habilitar NodeLocal DNSCache en un clúster existente, usa la marca --update-addons=NodeLocalDNS=ENABLED:

gcloud container clusters update cluster-name \
  --update-addons=NodeLocalDNS=ENABLED

Console

Puedes usar Google Cloud Console para habilitar NodeLocal DNSCache cuando crees un clúster nuevo.

  1. Ve al menú de Google Kubernetes Engine en Cloud Console.

    Ir al menú Google Kubernetes Engine

  2. Haz clic en Crear.

  3. En Nombre, ingresa cluster-name.

  4. En Zona, selecciona us-central1-a.

  5. En Cantidad de nodos, ingresa 1.

  6. En el panel de navegación, en Clúster, haz clic en Redes.

  7. En Opciones de red avanzadas, selecciona la casilla de verificación Habilitar NodeLocal DNSCache.

  8. Haga clic en Crear.

Verifica que NodeLocal DNSCache esté habilitado

Para verificar que NodeLocal DNSCache se esté ejecutando, enumera los pods node-local-dns. Debe haber un pod node-local-dns en ejecución en cada nodo que ejecute la versión 1.15 o posterior de GKE.

kubectl get pods -n kube-system -o wide | grep node-local-dns

Inhabilita NodeLocal DNSCache

NodeLocal DNSCache se puede inhabilitar con gcloud:

gcloud container clusters update cluster-name \
  --update-addons=NodeLocalDNS=DISABLED

Soluciona problemas de NodeLocal DNSCache

Consulta la página sobre depuración de la resolución de DNS para obtener información general sobre el diagnóstico de problemas de DNS de Kubernetes.

Valida la configuración del pod

Para verificar que un pod use NodeLocal DNSCache, verifica /etc/resolv.conf en el pod a fin de ver si el pod está configurado para usar el servidor de nombres correcto:

kubectl exec -it pod-name -- cat /etc/resolv.conf | grep nameserver

La dirección IP del servidor de nombres debe coincidir con el resultado de la dirección IP:

kubectl get svc -n kube-system kube-dns -o jsonpath="{.spec.clusterIP}"

Si la dirección IP del servidor de nombres configurada en /etc/resolv.conf no coincide, debes modificar la configuración para usar la dirección IP correcta del servidor de nombres.

Política de red con NodeLocal DNSCache

Cuando se usa NetworkPolicy con el complemento NodeLocalDNS, se necesitan reglas adicionales para permitir que los Pods node-local-dns envíen y reciban consultas de DNS. Usa una regla ipBlock en tu NetworkPolicy para permitir la comunicación entre los pods node-local-dns y kube-dns:

spec:
  egress:
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP
    to:
    - ipBlock:
        cidr: kube-dns-cluster-ip/32
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

Reemplaza kube-dns-cluster-ip por la dirección IP del servicio kube-dns que se obtuvo mediante el siguiente comando:

kubectl get svc -n kube-system kube-dns -o jsonpath="{.spec.clusterIP}"

En este ejemplo, se usa una regla ipBlock porque los Pods node-local-dns se ejecutan en modo hostNetwork:True. Una regla matchLabels no coincidiría con estos Pods.

¿Qué sigue?