¿Cómo instalo NodeLocalDNS en mi clúster de EKS y soluciono problemas?

Resolución

Requisitos previos:

• Comprueba que has configurado kubectl para acceder a tu clúster de Amazon EKS.
• Confirma que CoreDNS se está ejecutando en tu clúster.

Instalación de NodeLocalDNS

NodeLocalDNS usa una dirección IP local de enlace para proporcionar almacenamiento en caché de DNS en cada nodo. Las direcciones locales de enlace son direcciones IP del rango 169.254.0.0/16 que solo son válidas dentro del segmento de red.

Nota: La dirección IP local de enlace estándar para NodeLocalDNS es 169.254.20.10. No cambies este valor a menos que tengas un conflicto específico en tu entorno.

Para instalar NodeLocalDNS en tu clúster de Amazon EKS, completa los pasos siguientes:

1. Ejecuta el siguiente comando curl para descargar el manifiesto de NodeLocalDNS del repositorio de Kubernetes:

   curl -Lo nodelocaldns.yaml.template https://raw.githubusercontent.com/kubernetes/kubernetes/master/cluster/addons/dns/nodelocaldns/nodelocaldns.yaml

2. Para recuperar la dirección IP del servicio kube-dns de tu clúster, ejecuta el siguiente comando:

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

   Nota: Anota la dirección IP de la salida.

3. Para recuperar el dominio del clúster, ejecuta el siguiente comando:

   kubectl get configmap coredns -n kube-system -o yaml | grep 'kubernetes'

   El resultado muestra el dominio del clúster.

4. Para determinar el modo kube-proxy, ejecuta el siguiente comando:

   kubectl get configmap kube-proxy-config -n kube-system -o yaml | grep mode

   El resultado muestra iptables o ipvs como valor del modo.

5. Edita el manifiesto de NodeLocalDNS según tu modo kube-proxy.

   Para el modo iptables, edita el manifiesto con los siguientes comandos:

   # Set environment variables for node-local-dns
   kubedns=$(kubectl get svc kube-dns -n kube-system -o jsonpath={.spec.clusterIP})
   domain=cluster.local
   localdns=`169.254.20.10`
   
   # Update the manifest with your cluster's specific values:
   sed "s/__PILLAR__LOCAL__DNS__/$localdns/g; s/__PILLAR__DNS__DOMAIN__/$domain/g; s/__PILLAR__DNS__SERVER__/$kubedns/g" nodelocaldns.yaml.template > nodelocaldns.yaml

   Nota: Sustituye cluster.local por el dominio del clúster del paso 3 si el clúster usa un dominio diferente. Sustituye 169.254.20.10 por la dirección IP local de enlace de tu clúster, si es diferente.

   Para el modo IPVS, edita el manifiesto con los siguientes comandos:

   # Set environment variables for node-local-dns
   kubedns=$(kubectl get svc kube-dns -n kube-system -o jsonpath={.spec.clusterIP})
   domain=cluster.local
   localdns=169.254.20.10
   
   # Update the manifest with your cluster's specific values:
   sed "s/__PILLAR__LOCAL__DNS__/$localdns/g; s/__PILLAR__DNS__DOMAIN__/$domain/g; s/,__PILLAR__DNS__SERVER__//g; s/__PILLAR__CLUSTER__DNS__/$kubedns/g" nodelocaldns.yaml.template > nodelocaldns.yaml

   Nota: Sustituye cluster.local por el dominio del clúster del paso 3 si el clúster usa un dominio diferente. Sustituye 169.254.20.10 por la dirección IP local de enlace de tu clúster, si es diferente. En el modo IPVS, debes configurar los pods para que usen NodeLocalDNS. Consulta la sección Configuración de pods para usar NodeLocalDNS (solo en modo IPVS).

6. Para aplicar el manifiesto de NodeLocalDNS, ejecuta el siguiente comando:

   kubectl apply -f nodelocaldns.yaml

7. Para comprobar que los pods de NodeLocalDNS están en estado En ejecución, ejecuta el siguiente comando:

   kubectl get pods -n kube-system -l k8s-app=node-local-dns

Configuración de los pods para usar NodeLocalDNS (solo en modo IPVS)

Importante: Esta sección solo se aplica si el clúster usa el modo IPVS para kube-proxy. Si tu clúster usa el modo iptables, el tráfico de DNS se redirige automáticamente a NodeLocalDNS.

Para los clústeres en modo IPVS, debes configurar los pods manualmente para que usen NodeLocalDNS. Para dirigir tus pods a NodeLocalDNS, puedes configurar pods individuales o configurar clústeres con kubelet.

Configuración de pods individuales

Para configurar pods individuales, agrega la siguiente configuración a la especificación de tu pod:

spec:
  dnsPolicy: "None"
  dnsConfig:
    nameservers:
      - [169.254.20.10]
    searches:
      - default.svc.cluster.local
      - svc.cluster.local
      - cluster.local
    options:
      - name: ndots
        value: "5"

Nota: Sustituye 169.254.20.10 por la dirección IP local de enlace de tu clúster. Sustituye cluster.local por el dominio de tu clúster si este usa un dominio diferente.

Configuración de clústeres con kubelet

En el modo IPVS, NodeLocalDNS solo escucha en la dirección local del enlace 169.254.20.10. Debes modificar la configuración de kubelet para que apunte a esta dirección local del enlace.

Para configurar todos los pods de tu clúster para que usen NodeLocalDNS y modificar la configuración de kubelet en cada nodo, sigue estos pasos:

1. Edita el archivo de configuración de kubelet. Utiliza la siguiente configuración:

   {  "clusterDNS": ["169.254.20.10"],
     "clusterDomain": "cluster.local"
   }

   Nota: Sustituye 169.254.20.10 por la dirección IP local de enlace de tu clúster. Sustituye cluster.local por el dominio de tu clúster si este usa un dominio diferente.

2. Para reiniciar el servicio kubelet en cada nodo, ejecuta el siguiente comando sudo:

   sudo systemctl restart kubelet

3. Para verificar la configuración de kubelet, ejecuta el siguiente comando:

   cat /etc/kubernetes/kubelet/config.json | grep clusterDNS

   Nota: El resultado muestra 169.254.20.10 como la dirección IP local del enlace de NodeLocalDNS.

Nota: Para el despliegue automatizado, puedes modificar la configuración de kubelet en la sección de datos de usuario de tu plantilla de lanzamiento. Para obtener más información, consulta ¿Cómo uso los datos de usuario personalizados con los nodos AL2023 de Amazon EKS?

Comprobación de que has instalado correctamente NodeLocalDNS

Para comprobar que NodeLocalDNS funciona correctamente, sigue estos pasos:

1. Para crear un pod de prueba, ejecuta el siguiente comando:

   kubectl run test-dns --image=busybox:1.28 --restart=Never --rm -it -- nslookup kubernetes.default

2. Si los pods de NodeLocalDNS tienen un estado CrashLoopBackOff con errores que indican que el puerto 53 ya está en uso. A continuación, revisa el resultado para confirmar que la consulta de DNS se resolvió correctamente.

3. Para comprobar que las consultas de DNS utilizan NodeLocalDNS, ejecuta el siguiente comando:

   kubectl logs -n kube-system -l k8s-app=node-local-dns --tail=50

   Los registros muestran las consultas de DNS procesadas por NodeLocalDNS.

   Nota: De forma predeterminada, el registro no está activado en NodeLocalDNS. Para ver el registro, activa la opción de creación de registros en ConfigMap de node-local-dns.

   # kubectl edit configmaps -n kube-system node-local-dns
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: node-local-dns
     namespace: kube-system
   data:
     Corefile: |
       cluster.local:53 {
          log  # Enable logging
          errors
          cache 30
          ...
       }

Solución de problemas de NodeLocalDNS

Nota: Si se muestran errores al ejecutar comandos de la Interfaz de la línea de comandos de AWS (AWS CLI), consulta Solución de problemas de AWS CLI. Además, asegúrate de utilizar la versión más reciente de la AWS CLI.

Solución de errores de CrashLoopBackOff causados por conflictos de puertos

Si los pods de NodeLocalDNS entran a CrashLoopBackOff con errores en el puerto 53, esto se debe a que los nodos de modo automático de Amazon EKS reservan el puerto 53. Para solucionar este problema, utiliza uno de los siguientes métodos:

Método 1: Agrega reglas de afinidad de nodos para excluir los nodos en modo automático

Sigue estos pasos:

1. Edita el inicio del daemonset de NodeLocalDNS:

   kubectl edit daemonset node-local-dns -n kube-system

2. Agrega la siguiente configuración de afinidad en spec.template.spec:

   affinity:
     nodeAffinity:
       requiredDuringSchedulingIgnoredDuringExecution:
         nodeSelectorTerms:
         - matchExpressions:
           - key: eks.amazonaws.com/compute-type
             operator: NotIn
             values:
             - auto

3. Guarda los cambios y, a continuación, comprueba que los pods se reinician correctamente.

Método 2: Modifica ConfigMap de NodeLocalDNS para cambiar el puerto de comprobación de estado

Sigue estos pasos:

1. Para ver ConfigMap actual de NodeLocalDNS, ejecuta el siguiente comando:

   kubectl get configmap node-local-dns -n kube-system -o yaml

2. Para editar ConfigMap para cambiar el puerto de comprobación de estado, ejecuta el siguiente comando:

   kubectl edit configmap node-local-dns -n kube-system

3. En ConfigMap, localiza la configuración del complemento de estado y modifica el puerto. La estructura de ConfigMap tiene este aspecto:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: node-local-dns
     namespace: kube-system
   data:
     Corefile: |
       cluster.local:53 {
          errors
          cache {
             success 9984 30
             denial 9984 5
          }
          reload
          loop
          bind IP_ADDRESS
          forward. __PILLAR__CLUSTER__DNS__ {
             force_tcp
          }
          prometheus :9253
          health 169.254.20.10:8081
       }

   Nota: Sustituye el puerto de la línea de estado de 8081 por el puerto que desees. Sustituye 169.254.20.10 por la dirección IP local de enlace de tu clúster, si es diferente.

4. Guarda los cambios.

5. Para reiniciar los pods de NodeLocalDNS, ejecuta el siguiente comando:

   kubectl rollout restart daemonset node-local-dns -n kube-system

6. Para actualizar la configuración de comprobación de estado del daemonset para que coincida con el nuevo puerto, ejecuta el siguiente comando:

   kubectl edit daemonset node-local-dns -n kube-system

7. Busca las secciones livenessProbe y readinessProbe y actualiza el puerto para que coincida con tu nuevo puerto de comprobación de estado.

Solución de errores de tiempo de espera de consultas de DNS

Si tus pods experimentan tiempos de espera para las consultas de DNS, comprueba que los grupos de seguridad y la ACL de red permitan el tráfico TCP y UDP en el puerto 53. Este tráfico es necesario para la comunicación de un pod a otro.

Sigue estos pasos:

1. Para identificar los grupos de seguridad conectados a tus nodos, ejecuta el siguiente comando describe-instances de la AWS CLI:

   aws ec2 describe-instances --filters "Name=tag:eks:cluster-name,Values=YOUR-CLUSTER-NAME" --query "Reservations[*].Instances[*].SecurityGroups[*].[GroupId,GroupName]" --output table

   Nota: Sustituye YOUR-CLUSTER-NAME por el nombre de tu clúster de Amazon EKS.

2. Abre la consola de Amazon EC2.

3. En el panel de navegación, selecciona Grupos de seguridad.

4. Selecciona el grupo de seguridad identificado en el paso 1 de esta sección.

5. Selecciona la pestaña Reglas de entrada.

6. Comprueba que existan reglas para permitir el tráfico TCP y UDP en el puerto 53 del rango CIDR del pod.
   Nota: Si las reglas no existen, selecciona Editar reglas de entrada. A continuación, agrega reglas para TCP y UDP en el puerto 53 con el origen establecido en el rango CIDR de tu pod.

Solución de mensajes de error «Connection refused»

Si recibes mensajes de error «Connection refused» cuando los pods intentan usar NodeLocalDNS, comprueba que se estés ejecutando al menos un pod de CoreDNS.

Para comprobar el estado del pod de CoreDNS, ejecuta el siguiente comando:

kubectl get pods -n kube-system -l k8s-app=kube-dns

Si no hay ningún pod de CoreDNS en ejecución o si los pods están en estado de error, reinicia el despliegue de CoreDNS. Para reiniciar el despliegue, ejecuta el siguiente comando:

kubectl rollout restart deployment coredns -n kube-system

Para comprobar que los pods de CoreDNS se están ejecutando, ejecuta el siguiente comando:

kubectl get pods -n kube-system -l k8s-app=kube-dns -w

Una vez ejecutados los pods de CoreDNS, para reiniciar el daemonset de NodeLocalDNS, ejecuta el siguiente comando:

kubectl rollout restart daemonset node-local-dns -n kube-system

Información relacionada

Using CoreDNS for Service Discovery (Uso de CoreDNS para la detección de servicios) en el sitio web de Kubernetes

Run kube-proxy in IPVS Mode (Ejecución de kube-proxy en modo IPVS) en el sitio web de Kubernetes

Automatización de la infraestructura de clústeres con el modo automático de EKS

Administración de los complementos de red para los clústeres de Amazon EKS