Como solucionar falhas de DNS no Amazon EKS?

Breve descrição

Os pods executados dentro de um cluster do Amazon EKS usam o endereço IP do cluster do CoreDNS como servidor de nomes para consultar registros DNS internos e externos. Se houver problemas com os pods, configuração do serviço ou conectividade do CoreDNS, as aplicações poderão falhar nas resoluções de DNS.

O objeto de serviço kube-dns abstrai os pods do CoreDNS. Para solucionar problemas com pods do CoreDNS, verifique o status de funcionamento de todos os componentes do serviço kube-dns, como opções de endpoint de serviço e regras de iptables.

Resolução

Observação: na resolução a seguir, o valor do CoreDNS ClusterIP é 10.100.0.10.

Para verificar sua configuração de DNS, conclua as seguintes etapas:

1. Para obter o ClusterIP do seu serviço CoreDNS, execute o seguinte comando:

   kubectl get service kube-dns -n kube-system

2. Para verificar se os endpoints de DNS estão expostos e apontam para os pods do CoreDNS, execute o seguinte comando:

   kubectl -n kube-system get endpoints kube-dns

   Exemplo de saída:

   NAME       ENDPOINTS                                                        AGE
   kube-dns   192.168.2.218:53,192.168.3.117:53,192.168.2.218:53 + 1 more...   90d

   Observação: se a lista de endpoints estiver vazia, verifique o status dos pods do CoreDNS.

3. Confirme se seus grupos de segurança e sua lista de controle de acesso à rede (ACL da rede) não bloqueiam os pods quando eles se comunicam com o CoreDNS.

Para mais informações, consulte Por que meus pods não se conectam a outros pods no Amazon EKS?

Verifique se o pod do kube-proxy está funcionando

Para verificar se o pod do kube-proxy consegue acessar os servidores de API do seu cluster, verifique se há erros de tempo limite em seus logs do ambiente de gerenciamento. Além disso, verifique se há ocorrências do erro 403 unauthorized.

Para obter os logs do kube-proxy, execute o seguinte comando:

kubectl logs -n kube-system --selector 'k8s-app=kube-proxy'

Observação: o kube-proxy obtém os endpoints a partir do ambiente de gerenciamento e cria as regras do iptables em cada nó.

Verifique o uso da CPU do CoreDNS Pod no momento do problema

O complemento CoreDNS do Amazon EKS adiciona apenas a cota de 170 MiB à memória do pod do CoreDNS. O pod do CoreDNS não define uma cota para a CPU, portanto, o contêiner pode usar todos os recursos de CPU disponíveis no nó em que é executado. Se a utilização da CPU do nó atingir 100%, você poderá receber erros de tempo limite de DNS nos logs da sua aplicação do Amazon EKS. Isso ocorre porque o pod do CoreDNS não tem recursos de CPU suficientes para gerenciar todas as consultas de DNS.

Para verificar o uso atual da CPU e da memória dos pods CoreDNS, execute o seguinte comando:

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

Para verificar o uso atual da CPU e da memória dos nós do cluster do Amazon EKS, execute o seguinte comando:

kubectl top nodes

Conecte-se ao pod da aplicação para solucionar o problema de DNS

Conclua as etapas a seguir:

1. Para executar comandos dentro dos pods da aplicação, execute o seguinte comando:

   kubectl exec -it your-pod-name -- sh

   Observação: substitua your-pod-name pelo nome do seu pod.
   O comando anterior permite que você acesse um shell dentro do pod em execução. Se o pod da aplicação não tiver um binário de shell disponível, você receberá um erro semelhante ao exemplo a seguir:
   "OCI runtime exec failed: exec failed: container_linux.go:348: starting container process caused "exec: \"sh\": executable file not found in $PATH": unknown command terminated with exit code 126"
   Para resolver esse problema, atualize a imagem que você usa no arquivo de manifesto pod-manifest.yaml com outra imagem. Um exemplo de imagem é busybox no site do Docker.

2. Para verificar se o endereço IP do cluster do serviço kube-dns está no arquivo /etc/resolv.conf do seu pod, execute o seguinte comando no shell do pod:

   cat /etc/resolv.conf

   O exemplo de arquivo resolv.conf a seguir mostra um pod configurado para apontar as solicitações de DNS para 10.100.0.10. O endereço IP deve corresponder ao ClusterIP do serviço kube‑dns:

   nameserver 10.100.0.10
   search default.svc.cluster.local svc.cluster.local cluster.local ec2.internal
   options ndots:5

   Observação: é possível gerenciar a configuração de DNS do pod com o campo dnsPolicy na especificação do pod. Se você não preencher esse campo, o Amazon EKS usará a política de DNS ClusterFirst por padrão. Para obter mais informações sobre a política de DNS ClusterFirst, consulte Pod's DNS policy no site do Kubernetes.

3. Para verificar se o pod pode usar o ClusterIP padrão para resolver um domínio interno, execute o comando a seguir no shell dentro do pod:

   nslookup kubernetes.default 10.100.0.10

   Exemplo de saída:

   Server:     10.100.0.10
   Address:    10.100.0.10#53
   Name:       kubernetes.default.svc.cluster.local
   Address:    10.100.0.1

4. Para verificar se o pod pode usar o ClusterIP padrão para resolver um domínio externo, execute o comando a seguir no shell dentro do pod:

   nslookup amazon.com 10.100.0.10

   Exemplo de saída:

   Server:     10.100.0.10
   Address:    10.100.0.10#53
   Non-authoritative answer:
   Name:   amazon.com
   Address: 176.32.98.166
   Name:    amazon.com
   Address: 205.251.242.103
   Name:    amazon.com
   Address: 176.32.103.205

5. Para obter os endpoints kube-dns, execute o seguinte comando:

   kubectl get endpoints kube-dns -n kube-system

6. Para verificar se seu pod pode usar o endereço IP do pod CoreDNS para resolver diretamente, execute o seguinte comando no shell do pod:

   nslookup kubernetes COREDNS_POD_IP
   nslookup amazon.com COREDNS_POD_IP

   Observação: substitua COREDNS_POD_IP pelos endereços IP do endpoint kube-dns.

Obtenha logs detalhados dos pods do CoreDNS para depurar outros problemas

Conclua as etapas a seguir:

1. Para ativar o log de depuração do CoreDNS Pod e adicionar o plug-in de log ao ConfigMap do CoreDNS, execute o seguinte comando:

   kubectl -n kube-system edit configmap coredns

   Observação: para obter mais informações, consulte log no site do CoreDNS.
2. Na tela do editor da saída do comando, adicione a seguinte string de log:

   kind: ConfigMap
   apiVersion: v1
   data:
     Corefile: |
       .:53 {
           log    # Activating CoreDNS Logging
           errors
           health
           kubernetes cluster.local in-addr.arpa ip6.arpa {
             pods insecure
             upstream
             fallthrough in-addr.arpa ip6.arpa
           }
           ...
   ...

   Observação: demora alguns minutos para recarregar a configuração do CoreDNS. Para aplicar as alterações imediatamente, reinicie os pods um por um.
3. Para verificar se os logs do CoreDNS falham ou obtêm tráfego do pod da aplicação, execute o seguinte comando:

   kubectl logs --follow -n kube-system --selector 'k8s-app=kube-dns'

Atualize o valor de ndots

O valor de ndots é o número de pontos que deve aparecer em um nome de domínio para resolver uma consulta antes que uma consulta absoluta inicial seja feita. Por exemplo, é possível definir ndots como o padrão 5 em um nome de domínio que não seja totalmente qualificado. Assim, todos os domínios externos que não se enquadram no domínio interno cluster.local são anexados a domínios de pesquisa antes da consulta.

O exemplo a seguir tem a configuração do arquivo /etc/resolv.conf do pod da aplicação:

nameserver 10.100.0.10search default.svc.cluster.local svc.cluster.local cluster.local ec2.internal
options ndots:5

No exemplo de configuração anterior, o CoreDNS procura cinco pontos no domínio consultado. Se o pod fizer uma chamada de resolução de DNS para amazon.com, os logs serão parecidos com o exemplo a seguir:

[INFO] 192.168.3.71:33238 - 36534 "A IN amazon.com.default.svc.cluster.local. udp 54 false 512" NXDOMAIN qr,aa,rd 147 0.000473434s[INFO] 192.168.3.71:57098 - 43241 "A IN amazon.com.svc.cluster.local. udp 46 false 512" NXDOMAIN qr,aa,rd 139 0.000066171s
[INFO] 192.168.3.71:51937 - 15588 "A IN amazon.com.cluster.local. udp 42 false 512" NXDOMAIN qr,aa,rd 135 0.000137489s
[INFO] 192.168.3.71:52618 - 14916 "A IN amazon.com.ec2.internal. udp 41 false 512" NXDOMAIN qr,rd,ra 41 0.001248388s
[INFO] 192.168.3.71:51298 - 65181 "A IN amazon.com. udp 28 false 512" NOERROR qr,rd,ra 106 0.001711104s

Observação: NXDOMAIN significa que o pod não encontrou o registro do domínio. NOERROR significa que o pod encontrou com êxito o registro do domínio.

Cada domínio de pesquisa tem o prefixo amazon.com antes de fazer a chamada final no domínio absoluto que está no final. Um nome de domínio final acrescido de um ponto (.) no final é um nome de domínio totalmente qualificado. Para cada consulta de nome de domínio externo, pode haver quatro ou cinco chamadas adicionais que podem sobrecarregar o pod do CoreDNS.

Para resolver esse problema, altere ndots para 1 para procurar somente um ponto. Ou acrescente um ponto no final do domínio consultado ou usado. Exemplo:

nslookup example.com.

Verifique as cotas de resolvedor de VPC do AmazonProvidedDNS

O resolvedor Amazon Virtual Private Cloud (Amazon VPC) pode aceitar uma cota máxima de 1.024 pacotes em um segundo para cada interface de rede elástica. Se mais de um pod CoreDNS estiver no mesmo nó, você poderá atingir essa cota para consultas de domínio externo.

Para usar as regras do PodAntiAffinity para programar os pods do CoreDNS em instâncias separadas, adicione as opções a seguir à implantação do CoreDNS:

podAntiAffinity:
  preferredDuringSchedulingIgnoredDuringExecution:
  - podAffinityTerm:
      labelSelector:
        matchExpressions:
        - key: k8s-app
          operator: In
          values:
          - kube-dns
      topologyKey: kubernetes.io/hostname
    weight: 100

Observação: para obter mais informações sobre o PodAntiAffinity, consulte Inter-pod affinity and anti-affinity no site do Kubernetes.

Use o tcpdump para capturar pacotes do CoreDNS a partir dos nós de processamento do Amazon EKS

Para diagnosticar problemas de resolução de DNS, conclua as etapas a seguir para usar a ferramenta tcpdump para realizar uma captura de pacotes:

1. Para localizar um nó de processamento em que um pod CoreDNS esteja em execução, execute o seguinte comando:

   kubectl get pod -n kube-system -l k8s-app=kube-dns -o wide

2. Para usar o SSH para se conectar ao nó de processamento e instalar a ferramenta tcpdump, execute o seguinte comando:

   sudo yum install tcpdump - y

3. Para localizar o ID do processo do pod CoreDNS no nó de processamento, execute o seguinte comando:

   ps ax | grep coredns

4. No nó de processamento, execute o seguinte comando para realizar uma captura de pacotes no tráfego de rede do pod CoreDNS na porta 53 UDP:

   sudo nsenter -n -t PID tcpdump udp port 53

5. Em um terminal separado, execute o seguinte comando para obter o serviço CoreDNS e o endereço IP do pod:

   kubectl describe svc kube-dns -n kube-system

   Observação: anote o endereço IP do serviço no campo IP e o endereço IP do pod no campo Endpoints.

6. Inicie um pod para testar o serviço DNS. O exemplo a seguir usa uma imagem de contêiner do Ubuntu:

   kubectl run ubuntu --image=ubuntu sleep 1d
   kubectl exec -it ubuntu sh

7. Execute o comando a seguir para usar a ferramenta nslookup para realizar uma consulta ao DNS no domínio amazon.com:

   nslookup amazon.com

   Para executar explicitamente a mesma consulta no endereço IP do serviço CoreDNS, execute o seguinte comando:

   nslookup amazon.com COREDNS_SERVICE_IP

   Observação: substitua COREDNS_SERVICE_IP pelo endereço IP do serviço CoreDNS.
   Para realizar a consulta em cada endereço IP do pod CoreDNS, execute o seguinte comando:

   nslookup amazon.com COREDNS_POD_IP

   Observação: substitua COREDNS_POD_IP pelo endereço IP do pod CoreDNS. Se você executar vários pods CoreDNS, execute várias consultas. Dessa forma, o Amazon EKS envia pelo menos uma consulta ao pod do qual você captura o tráfego.

8. Examine os resultados da captura de pacotes.
   Se o pod do CoreDNS monitorado apresentar tempos limite de consulta ao DNS e você não vir a consulta na captura de pacotes, verifique sua conectividade de rede. Verifique a acessibilidade da rede entre os nós de processamento.
   Se você observar tempos limite de consulta ao DNS em um endereço IP de pod que você não capturou, execute outra captura de pacote no nó de processamento relacionado.
   Para salvar os resultados de uma captura de pacote, adicione o sinalizador -w FILE_NAME ao comando tcpdump. O exemplo a seguir grava os resultados no arquivo chamado capture.pcap:

   tcpdump -w capture.pcap udp port 53

Informações relacionadas

CoreDNS GA for Kubernetes cluster DNS (Disponibilidade geral do CoreDNS para clusters do Kubernetes) no site do Kubernetes