Personalizar o CoreDNS com o Serviço de Kubernetes do Azure

Artigo
11/02/2024

O AKS (Serviço Kubernetes do Azure) usa o projeto CoreDNS para a resolução e o gerenciamento de DNS do cluster com todos os clusters 1.12. x e superiores. Para obter mais informações sobre Kubernetes e personalização do CoreDNS, confira a documentação oficial do upstream.

O AKS é um serviço gerenciado, portanto, você não pode modificar a configuração principal do CoreDNS (um CoreFile). Em vez disso, você usa um ConfigMap do Kubernetes para substituir as configurações padrão. Para ver os ConfigMaps padrão de CoreDNS do AKS, use o comando kubectl get configmaps --namespace=kube-system coredns -o yaml.

Este artigo mostra como usar o ConfigMaps para as opções básicas de personalização do CoreDNS no AKS. Essa abordagem difere da configuração do CoreDNS em outros contextos, como o CoreFile.

Observação

Anteriormente, kube-dns era usado para gerenciamento e resolução de DNS de cluster, mas agora foi preterido. Em kube-dns são oferecidas diferentes Opções de personalização por meio de um mapa de configuração do Kubernetes. O CoreDNS não é compatível com versões anteriores do kube-dns. Todas as personalizações que você usou anteriormente precisam ser atualizadas para o CoreDNS.

Antes de começar

Este artigo considera que já existe um cluster do AKS. Se você precisar de um cluster do AKS, crie um usando a CLI do Azure, o Azure PowerShell ou o portal do Azure.
Verifique a versão do CoreDNS que você está executando. Os valores de configuração podem ser alterados entre as versões.
Ao criar configurações como os exemplos abaixo, seus nomes na seção dados devem terminar em .server ou .override. Essa convenção de nomenclatura é definida no ConfigMap do CoreDNS do AKS padrão, que você pode visualizar usando o comando kubectl get configmaps --namespace=kube-system coredns -o yaml.

Suporte ao plug-in

Todos os plug-ins CoreDNS embutidos são compatíveis. Nenhum complemento/plug-in de terceiros é compatível.

Regravar o DNS

Você pode personalizar o CoreDNS com o AKS para executar reescritas de nome DNS sem interrupção.

Crie um arquivo chamado corednsms.yaml e cole a seguinte configuração de exemplo. Substitua <domain to be rewritten> pelo seu próprio nome de domínio totalmente qualificado.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: |
    <domain to be rewritten>.com:53 {
    log
    errors
    rewrite stop {
      name regex (.*)\.<domain to be rewritten>\.com {1}.default.svc.cluster.local
      answer name (.*)\.default\.svc\.cluster\.local {1}.<domain to be rewritten>.com
    }
    forward . /etc/resolv.conf # you can redirect this to a specific DNS server such as 10.0.0.10, but that server must be able to resolve the rewritten domain name
    }

Importante

Se você redirecionar para um servidor DNS, como o IP do serviço CoreDNS, esse servidor DNS precisará ser capaz de resolver o nome de domínio regravado.

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Verifique se as personalizações foram aplicadas usando o kubectl get configmaps e especifique o ConfigMap coredns-custom.
```
kubectl get configmaps --namespace=kube-system coredns-custom -o yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns
```

Servidor de encaminhamento personalizado

Se você precisar especificar um servidor de encaminhamento para o tráfego de rede, poderá criar um ConfigMap para personalizar o DNS.

Crie um arquivo chamado corednsms.yaml e cole a seguinte configuração de exemplo. Substitua o nome forward e o endereço pelos valores do seu próprio ambiente.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: | # you may select any name here, but it must end with the .server file extension
    <domain to be rewritten>.com:53 {
        forward foo.com 1.1.1.1
    }

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns
```

Usar domínios personalizados

Talvez você queira configurar domínios personalizados que só podem ser resolvidos internamente. Por exemplo, talvez você queira resolver o domínio personalizado puglife.local, que não é um domínio primário. Sem um ConfigMap de domínio personalizado, o cluster do AKS não pode resolver o endereço.

Crie um novo arquivo chamado corednsms.yaml e cole a seguinte configuração de exemplo. Certifique-se de atualizar o domínio personalizado e o endereço IP com os valores do seu próprio ambiente.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  puglife.server: | # you may select any name here, but it must end with the .server file extension
    puglife.local:53 {
        errors
        cache 30
        forward . 192.11.0.1  # this is my test/dev DNS server
    }

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns 
```

Domínios stub

O CoreDNS também pode ser usado para configurar domínios stub.

Crie um arquivo chamado corednsms.yaml e cole a seguinte configuração de exemplo. Certifique-se de atualizar os domínios personalizados e os endereços IP com os valores do seu próprio ambiente.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  test.server: | # you may select any name here, but it must end with the .server file extension
    abc.com:53 {
     errors
     cache 30
     forward . 1.2.3.4
    }
    my.cluster.local:53 {
        errors
        cache 30
        forward . 2.3.4.5
    }

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns
```

Plug-in de hosts

Todos os plug-ins internos são compatíveis, portanto, os plug-in dos hosts CoreDNS também estão disponíveis para personalizar os /etc/hosts.

Crie um arquivo chamado corednsms.yaml e cole a seguinte configuração de exemplo. Certifique-se de atualizar os domínios personalizados e os endereços de IP com os valores do seu próprio ambiente.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom # this is the name of the configmap you can overwrite with your changes
  namespace: kube-system
data:
    test.override: | # you may select any name here, but it must end with the .override file extension
          hosts { 
              10.0.0.1 example1.org
              10.0.0.2 example2.org
              10.0.0.3 example3.org
              fallthrough
          }

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns
```

Preenchimentos de domínio de pesquisa inválido para internal.cloudapp.net e reddog.microsoft.com

O DNS do Azure configura um domínio de pesquisa padrão igual a <vnetId>.<region>.internal.cloudapp.net nas redes virtuais usando o DNS do Azure e um stub não funcional reddog.microsoft.com nas redes virtuais usando servidores DNS personalizados (consulte a documentação sobre resolução de nomes para recursos para obter mais detalhes). O Kubernetes define as configurações de DNS de pod para ndots: 5 a fim de dar suporte adequado à resolução de nomes de host do serviço de cluster. Essas duas configurações se combinam para resultar em consultas de preenchimento de domínio de pesquisa inválido que nunca conseguem ser enviadas para servidores de nomes upstream enquanto o sistema as processa por meio da lista de pesquisa de domínio. Essas consultas inválidas causam atrasos na resolução de nomes e podem colocar carga extra em servidores DNS upstream.

A partir da versão v20241025 do AKS, o AKS configura o CoreDNS para responder com o NXDOMAIN nos dois seguintes casos, a fim de impedir que essas consultas de preenchimento de domínio de pesquisa inválido sejam encaminhadas para o DNS upstream:

Qualquer consulta para o domínio raiz ou um subdomínio de reddog.microsoft.com.
Qualquer consulta para um subdomínio de internal.cloudapp.net que tenha sete ou mais rótulos no nome de domínio.
- Essa configuração permite que a resolução de máquina virtual por nome do host ainda seja bem-sucedida. Por exemplo, o CoreDNS envia aks12345.myvnetid.myregion.internal.cloudapp.net (seis rótulos) para o DNS do Azure, mas rejeita mcr.microsoft.com.myvnetid.myregion.internal.cloudapp.net (oito rótulos)

Esse bloco é implementado no bloco de servidor padrão no Corefile para o cluster. Se necessário, essa configuração de rejeição pode ser desabilitada com a criação de blocos de servidor personalizados para o domínio apropriado com um plug-in de encaminhamento habilitado:

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom # this is the name of the configmap you can overwrite with your changes
  namespace: kube-system
data:
    override-block.server:
       internal.cloudapp.net:53 {
           errors
           cache 30
           forward . /etc/resolv.conf
       }
       reddog.microsoft.com:53 {
           errors
           cache 30
           forward . /etc/resolv.conf
       }

Crie o ConfigMap usando o comando kubectl apply configmap e especifique o nome do seu manifesto YAML.
```
kubectl apply -f corednsms.yaml
```
Para recarregar o ConfigMap e habilitar o Agendador do Kubernetes para reiniciar o CoreDNS sem tempo de inatividade, execute uma reinicialização sem interrupção usando kubectl rollout restart.
```
kubectl -n kube-system rollout restart deployment coredns
```

Solução de problemas

Para ver as etapas gerais de solução de problemas do CoreDNS, como verificar os pontos de extremidade ou a resolução, confira Depurar a resolução do DNS.

Configurar o dimensionamento de pods CoreDNS

Picos repentinos no tráfego DNS em clusters do AKS são uma ocorrência comum devido à elasticidade que o AKS fornece para cargas de trabalho. Esses picos podem levar a um aumento no consumo de memória por pods CoreDNS. Em alguns casos, esse aumento no consumo de memória pode causar Out of memory problemas. Para antecipar esse problema, os clusters do AKS dimensionam automaticamente pods CoreDNS para reduzir o uso de memória por pod. As configurações padrão para essa lógica de dimensionamento automático são armazenadas no coredns-autoscaler ConfigMap. No entanto, você pode observar que o dimensionamento automático padrão de pods CoreDNS nem sempre é agressivo o suficiente para evitar Out of memory problemas para seus pods CoreDNS. Nesse caso, você pode modificar diretamente o coredns-autoscaler ConfigMap. Observe que simplesmente aumentar o número de pods CoreDNS sem abordar a causa raiz do Out of memory problema pode fornecer apenas uma correção temporária. Se não houver memória suficiente disponível nos nós em que os pods CoreDNS estão em execução, aumentar o número de pods CoreDNS não ajudará. Talvez seja necessário investigar mais e implementar soluções apropriadas, como otimizar o uso de recursos, ajustar solicitações e limites de recursos ou adicionar mais memória aos nós.

O CoreDNS usa o dimensionador automático proporcional de cluster horizontal para dimensionamento automático de pod. O coredns-autoscaler ConfigMap pode ser editado para configurar a lógica de dimensionamento para o número de pods CoreDNS. O coredns-autoscaler ConfigMap atualmente dá suporte a dois valores de chave ConfigMap diferentes: linear e ladder que correspondem a dois modos de controle com suporte. O linear controlador produz um número de réplicas no intervalo [min,max] equivalente a max( ceil( cores * 1/coresPerReplica ) , ceil( nodes * 1/nodesPerReplica ) ). O ladder controlador calcula o número de réplicas consultando duas funções de etapa diferentes, uma para dimensionamento de núcleo e outra para dimensionamento de nó, gerando o máximo dos dois valores de réplica. Para obter mais informações sobre os modos de controle e o formato ConfigMap, consulte a documentação do upstream.

Importante

É recomendável um mínimo de 2 réplicas de pod do CoreDNS por cluster. Configurar um mínimo de 1 réplica de pod do CoreDNS pode causar falhas durante operações que exigem esvaziamento de nós, como operações de atualização de cluster.

Para recuperar o coredns-autoscaler ConfigMap, você pode executar o kubectl get configmap coredns-autoscaler -n kube-system -o yaml comando que retornará o seguinte:

apiVersion: v1
data:
  ladder: '{"coresToReplicas":[[1,2],[512,3],[1024,4],[2048,5]],"nodesToReplicas":[[1,2],[8,3],[16,4],[32,5]]}'
kind: ConfigMap
metadata:
  name: coredns-autoscaler
  namespace: kube-system
  resourceVersion: "..."
  creationTimestamp: "..."

habilitar o registro em log de consulta DNS

Adicione a seguinte configuração ao ConfigMap coredns-custom:

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: kube-system
data:
  log.override: | # you may select any name here, but it must end with the .override file extension
        log

Aplique as alterações de configuração e force o CoreDNS a recarregar o ConfigMap usando os seguintes comandos:

# Apply configuration changes
kubectl apply -f corednsms.yaml

# Force CoreDNS to reload the ConfigMap
kubectl -n kube-system rollout restart deployment coredns

Exiba o log de depuração do CoreDNS usando o comando kubectl logs.
```
kubectl logs --namespace kube-system -l k8s-app=kube-dns
```

Próximas etapas

Este artigo mostrou alguns cenários de exemplo para a personalização do CoreDNS. Para obter informações sobre o projeto CoreDNS, confira a página de projeto upstream do CoreDNS.

Para saber mais sobre os principais conceitos de rede, confira Conceitos de rede para aplicativos no AKS.

Compartilhar via