Como faço para instalar o NodeLocalDNS no meu cluster do EKS e solucionar problemas?

Resolução

Pré-requisitos:

• Verifique se você configurou o kubectl para acessar seu cluster do Amazon EKS.
• Confirme se CoreDNS está sendo executado em seu cluster.

Instale o NodeLocalDNS

O NodeLocalDNS usa um endereço IP link-local para fornecer cache de DNS em cada nó. Endereços link-local são endereços IP no intervalo 169.254.0.0/16 que são válidos somente dentro do segmento de rede.

Observação: o endereço IP link-local padrão para o NodeLocalDNS é 169.254.20.10. Não altere esse valor a menos que você tenha um conflito específico em seu ambiente.

Para instalar o NodeLocalDNS em seu cluster do Amazon EKS, conclua as seguintes etapas:

1. Execute o seguinte comando curl para baixar o manifesto NodeLocalDNS do repositório do Kubernetes:

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

2. Para recuperar o endereço IP do serviço kube-dns do seu cluster, execute o seguinte comando:

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

   Observação: anote o endereço IP da saída.

3. Para recuperar o domínio do seu cluster, execute o seguinte comando:

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

   A saída mostra o cluster do seu domínio.

4. Para descobrir o modo do seu kube-proxy, execute o seguinte comando:

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

   A saída mostra iptables ou ipvs como o valor do modo.

5. Edite o manifesto NodeLocalDNS com base no modo do seu kube-proxy.

   Para o modo iptables, edite o manifesto com os seguintes 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

   Observação: substitua cluster.local pelo domínio do seu cluster na etapa 3 se o cluster usar um domínio diferente. Substitua 169.254.20.10 pelo endereço IP link-local do seu cluster, se for diferente.

   Para o modo IPVS, edite o manifesto com os seguintes 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

   Observação: substitua cluster.local pelo domínio do seu cluster na etapa 3 se o cluster usar um domínio diferente. Substitua 169.254.20.10 pelo endereço IP link-local do seu cluster, se for diferente. No modo IPVS, você precisa configurar os pods para usar NodeLocalDNS. Consulte a seção "Configure os pods para usar o NodeLocalDNS (somente no modo IPVS)".

6. Para aplicar o manifesto NodeLocalDNS, execute o seguinte comando:

   kubectl apply -f nodelocaldns.yaml

7. Para verificar se os pods do NodeLocalDNS estão no status Em execução, execute o seguinte comando:

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

Configure os pods para usar o NodeLocalDNS (somente no modo IPVS)

Importante: esta seção se aplica somente se o cluster usar o modo IPVS no kube-proxy. Se seu cluster usa o modo iptables, o tráfego DNS é redirecionado automaticamente para NodeLocalDNS.

Em clusters no modo IPVS, você deve configurar manualmente os pods para usar NodeLocalDNS. Para direcionar seus pods para NodeLocalDNS, é possível configurar pods individuais ou configurar clusters com o kubelet.

Configure pods individuais

Para configurar pods individuais, adicione a seguinte configuração à sua especificação de 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"

Observação: substitua 169.254.20.10 pelo endereço IP link-local do seu cluster. Substitua cluster.local pelo domínio do seu cluster se seu cluster usar um domínio diferente.

Configure clusters com o kubelet

No modo IPVS, o NodeLocalDNS recebe apenas no endereço link-local 169.254.20.10. Você deve modificar a configuração do kubelet para apontar para esse endereço link-local.

Para configurar todos os pods em seu cluster para usar o NodeLocalDNS e modificar a configuração do kubelet em cada nó, conclua as seguintes etapas:

1. Edite o arquivo de configuração do kubelet. Use a configuração a seguir:

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

   Observação: substitua 169.254.20.10 pelo endereço IP link-local do seu cluster. Substitua cluster.local pelo domínio do seu cluster se seu cluster usar um domínio diferente.

2. Para reiniciar o serviço kubelet em cada nó, execute o seguinte comando sudo:

   sudo systemctl restart kubelet

3. Para verificar a configuração do kubelet, execute o seguinte comando:

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

   Observação: a saída mostra 169.254.20.10 como o endereço IP link-local NodeLocalDNS.

Observação: para implantação automatizada, é possível modificar a configuração do kubelet na seção userdata do seu modelo de execução. Para obter mais informações, consulte Como faço para usar dados personalizados do usuário com os nós AL2023 do Amazon EKS?

Verifique se você instalou corretamente o NodeLocalDNS

Para verificar se o NodeLocalDNS está funcionando corretamente, conclua as seguintes etapas:

1. Para criar um pod de teste, execute o seguinte comando:

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

2. Se os pods NodeLocalDNS tiverem um status CrashLoopBackOff com erros que indiquem que a porta 53 já está em uso. Em seguida, analise a saída para confirmar se a consulta ao DNS foi resolvida corretamente.

3. Para verificar se as consultas ao DNS estão usando o NodeLocalDNS, execute o seguinte comando:

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

   Os logs mostram consultas ao DNS sendo processadas pelo NodeLocalDNS.

   Observação: por padrão, o registro em log não é ativado no NodeLocalDNS. Para visualizar o log, ative o registro em log no node-local-dns ConfigMap.

   # 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
          ...
       }

Solucione problemas de NodeLocalDNS

Observação: se você receber mensagens de erro ao executar comandos da AWS Command Line Interface (AWS CLI), consulte Solução de problemas da AWS CLI. Além disso, verifique se você está usando a versão mais recente da AWS CLI.

Resolva erros de CrashLoopBackOff causados por conflitos de porta

Se os pods do NodeLocalDNS entrarem no CrashLoopBackOff com erros na porta 53, isso ocorre porque os nós de modo automático do Amazon EKS reservam a porta 53. Para solucionar esse problema, use um dos seguintes métodos:

Método 1: Adicione regras de afinidade de nós para excluir nós de modo automático

Conclua as etapas a seguir:

1. Edite o daemonset do NodeLocalDNS:

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

2. Adicione a seguinte configuração de afinidade em spec.template.spec:

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

3. Salve as alterações e verifique se os pods foram reiniciados com êxito.

Método 2: Modifique o NodeLocalDNS ConfigMap para alterar a porta de verificação de integridade

Conclua as etapas a seguir:

1. Para visualizar o NodeLocalDNS ConfigMap atual, execute o seguinte comando:

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

2. Para editar o ConfigMap para alterar a porta de verificação de integridade, execute o seguinte comando:

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

3. No ConfigMap, localize a configuração do plug-in de integridade e modifique a porta. A estrutura do ConfigMap tem a seguinte aparência:

   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
       }

   Observação: substitua a porta na linha de integridade de 8081 pela porta desejada. Substitua 169.254.20.10 pelo endereço IP link-local do seu cluster, se for diferente.

4. Salve as alterações.

5. Para reiniciar os pods do NodeLocalDNS, execute o seguinte comando:

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

6. Para atualizar a configuração de verificação de integridade do daemonset corresponder à nova porta, execute o seguinte comando:

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

7. Localize as seções livenessProbe e readinessProbe e atualize a porta corresponder à sua nova porta de verificação de integridade.

Resolva erros de tempo limite de consulta ao DNS

Se seus pods enfrentarem tempo limite de consulta ao DNS, verifique se seus grupos de segurança e a ACL da rede permitem tráfego TCP e UDP na porta 53. Esse tráfego é necessário para a comunicação entre pods.

Conclua as etapas a seguir:

1. Para identificar os grupos de segurança anexados aos seus nós, execute o seguinte comando describe-instances da AWS CLI:

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

   Observação: substitua YOUR-CLUSTER-NAME pelo nome do seu cluster do Amazon EKS.

2. Abra o console do Amazon EC2.

3. No painel de navegação, clique em Grupos de segurança.

4. Selecione o grupo de segurança identificado na etapa 1 desta seção.

5. Clique na guia Regras de entrada.

6. Verifique se existem regras para permitir tráfego TCP e UDP na porta 53 do intervalo CIDR do pod.
   Observação: se as regras não existirem, selecione Editar regras de entrada. Em seguida, adicione regras para TCP e UDP na porta 53 com a origem definida no intervalo CIDR do seu pod.

Resolva mensagens de erro "Connection refused"

Se você receber mensagens de erro "Connection refused" quando os pods tentarem usar o NodeLocalDNS, verifique se pelo menos um pod CoreDNS está em execução.

Para verificar o status do pod CoreDNS, execute o seguinte comando:

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

Se nenhum pod do CoreDNS estiver em execução ou se os pods estiverem em um estado de falha, reinicie a implantação do CoreDNS. Para reiniciar a implantação, execute o seguinte comando:

kubectl rollout restart deployment coredns -n kube-system

Para verificar se os pods do CoreDNS estão em execução, execute o seguinte comando:

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

Depois que os pods do CoreDNS estiverem em execução, execute o seguinte comando para reiniciar o daemonset do NodeLocalDNS:

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

Informações relacionadas

Usando o CoreDNS para descoberta de serviços no site do Kubernetes

Run kube-proxy in IPVS Mode (Execute kube-proxy no modo IPVS) no site do Kubernetes

Automatizar a infraestrutura de clusters com o modo automático do EKS

Gerenciar os complementos de redes para os clusters do Amazon EKS