Configurer NodeLocal DNSCache

Cette page explique comment configurer NodeLocal DNSCache sur un cluster Google Kubernetes Engine (GKE). NodeLocal DNSCache améliore la latence de la résolution DNS, rend les durées de résolution DNS plus cohérentes et réduit le nombre de requêtes DNS à kube-dns en exécutant un cache DNS sur chaque nœud de cluster.

Pour obtenir un aperçu de la façon dont fonctionnent la détection de services et le DNS géré sur GKE, consultez la section Détection de services et DNS.

Présentation

NodeLocal DNSCache est un module complémentaire GKE facultatif que vous pouvez exécuter en plus de kube-dns. NodeLocal DNSCache est mis en œuvre en tant que DaemonSet qui exécute un cache DNS sur chaque nœud de votre cluster. Lorsqu'un pod effectue une requête DNS, celle-ci est envoyée au cache DNS exécuté sur le même nœud que le pod. Si le cache ne peut pas résoudre la requête DNS, il la transfère à :

  • Cloud DNS pour les requêtes de nom d'hôte externe. Ces requêtes sont transmises à Cloud DNS par le serveur de métadonnées local exécuté sur le même nœud que le pod à l'origine de la requête.
  • kube-dns pour toutes les autres requêtes DNS. Le service kube-dns-upstream est utilisé par les pods node-local-dns pour contacter les pods kube-dns.

Schéma du chemin d'une requête DNS, comme décrit dans le paragraphe précédent

Les pods n'ont pas besoin d'être modifiés pour utiliser NodeLocal DNSCache. NodeLocal DNSCache consomme des ressources de calcul sur chaque nœud de votre cluster.

Avantages de NodeLocal DNSCache

  • Durée moyenne de résolution DNS réduite
  • Les correspondances entre les pods et leur cache local ne créent pas d'entrées de table conntrack. Cela évite les correspondances supprimées et rejetées en raison de l'épuisement de la table conntrack et des conditions de concurrence.

Détails

  • NodeLocal DNSCache nécessite la version 1.15 ou ultérieure de GKE.
  • Les correspondances entre le cache DNS local et kube-dns utilisent TCP au lieu d'UDP pour plus de fiabilité.
  • Les requêtes DNS pour les URL externes (URL qui ne font pas référence aux ressources du cluster) sont transmises directement au serveur de métadonnées Cloud DNS local, et contournent ainsi kube-dns.
  • Les caches DNS locaux récupèrent automatiquement des domaines de simulation et des serveurs de noms en amont spécifiés dans le fichier ConfigMap de kube-dns.

  • Les enregistrements DNS sont mis en cache pendant :

    • la durée de vie de l'enregistrement, ou pour une durée de 30 secondes si la valeur TTL est supérieure à 30 secondes.
    • 5 secondes si la réponse DNS est NXDOMAIN.
  • Les pods NodeLocal DNSCache écoutent les ports 53, 9253 et 8080 sur les nœuds. L'exécution de tout autre pod hostNetwork à l'aide des ports ci-dessus ou la configuration de hostPorts à l'aide des ports ci-dessus entraînent l'échec de NodeLocal DNSCache et génèrent des erreurs DNS.

Activer NodeLocal DNSCache

Vous pouvez activer NodeLocal DNSCache dans un cluster existant ou lorsque vous créez un cluster. L'activation de NodeLocal DNSCache dans un cluster existant est un processus perturbateur. Tous les nœuds de cluster exécutant la version 1.15 et ultérieure de GKE sont recréés. Les nœuds sont recréés conformément au processus de mise à niveau des nœuds GKE.

gcloud

Activer NodeLocal DNSCache dans un nouveau cluster

Pour activer NodeLocal DNSCache dans un nouveau cluster, utilisez l'option --addons NodeLocalDNS :

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

Remplacez les éléments suivants :

  • cluster-name : nom de votre nouveau cluster
  • compute-zone : zone de votre cluster
  • cluster-version : version de votre cluster (version 1.15 ou ultérieure)

Activer NodeLocal DNSCache dans un cluster existant

Pour activer NodeLocal DNSCache dans un cluster existant, utilisez l'option --update-addons=NodeLocalDNS=ENABLED :

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

Console

Vous pouvez utiliser Google Cloud Console pour activer NodeLocal DNSCache lors de la création d'un cluster.

  1. Accédez à la page "Créer un cluster Kubernetes" dans Cloud Console.

    Accéder à la page des clusters Kubernetes

  2. Dans le champ Nom, saisissez cluster-name.

  3. Pour la Zone, sélectionnez us-central1-a.

  4. Dans le champ Nombre de nœuds, saisissez 1.

  5. À gauche de la page, cliquez sur Mise en réseau.

  6. Cochez la case Activer NodeLocal DNSCache sous Options de mise en réseau avancées.

  7. Cliquez sur Créer.

Vérifier que NodeLocal DNSCache est activé

Vous pouvez vérifier que NodeLocal DNSCache est en cours d'exécution en répertoriant les pods node-local-dns. Un pod node-local-dns doit être exécuté sur chaque nœud exécutant la version 1.15 ou ultérieure de GKE.

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

Désactiver NodeLocal DNSCache

NodeLocal DNSCache peut être désactivé à l'aide de gcloud :

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

Résoudre les problèmes liés à NodeLocal DNSCache

Consultez la section Déboguer la résolution DNS pour obtenir des informations générales sur l'analyse des problèmes de DNS de Kubernetes.

Valider la configuration du pod

Pour vérifier qu'un pod utilise NodeLocal DNSCache, vérifiez /etc/resolv.conf sur le pod pour savoir si celui-ci a été configuré pour utiliser le serveur de noms approprié :

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

L'adresse IP du serveur de noms doit correspondre à l'adresse IP émise par :

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

Si l'adresse IP du serveur de noms configurée dans /etc/resolv.conf ne correspond pas, vous devez modifier la configuration afin d'utiliser l'adresse IP du serveur de noms approprié.

Règle de réseau avec NodeLocal DNSCache

Lorsque vous utilisez une règle NetworkPolicy avec le module complémentaire NodeLocalDNS, des règles supplémentaires sont nécessaires pour autoriser les pods node-local-dns à envoyer et recevoir des requêtes DNS. Utilisez une règle ipBlock dans votre objet NetworkPolicy pour autoriser la communication entre les pods node-local-dns et 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

Remplacez kube-dns-cluster-ip par l'adresse IP du service kube-dns obtenue à l'aide de la commande suivante :

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

Cet exemple utilise une règle ipBlock, car les pods node-local-dns s'exécutent en mode hostNetwork:True. Une règle matchLabels ne trouverait aucune correspondance avec ces pods.

Étape suivante