CoreDNS — DNS interne de Kubernetes

CoreDNS est le DNS par défaut de Kubernetes depuis la version 1.13. Il permet aux Pods de résoudre les noms de Services (my-service.my-namespace.svc.cluster.local) en adresses IP ClusterIP. Sans DNS fonctionnel, la communication inter-Pods par nom de Service ne fonctionne pas.

Ce guide couvre CoreDNS pour la certification CKA, où le dépannage DNS représente une compétence clé du domaine Troubleshooting (30%).

Ce que vous allez apprendre

• Comment fonctionne la résolution DNS dans Kubernetes
• La syntaxe des noms de Services (service.namespace.svc.cluster.local)
• Comment configurer CoreDNS via le Corefile
• Les techniques de dépannage DNS pour la CKA
• Les erreurs courantes et leurs solutions

Comment fonctionne le DNS Kubernetes

Architecture DNS

┌─────────────────────────────────────────────────────────────────┐
│                          Cluster Kubernetes                      │
│                                                                   │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────┐      │
│  │   Pod A     │      │   Pod B     │      │   Pod C     │      │
│  │             │      │             │      │             │      │
│  │ /etc/resolv │      │ /etc/resolv │      │ /etc/resolv │      │
│  │ nameserver  │      │ nameserver  │      │ nameserver  │      │
│  │ <DNS_IP>    │      │ <DNS_IP>    │      │ <DNS_IP>    │      │
│  └──────┬──────┘      └──────┬──────┘      └──────┬──────┘      │
│         │                    │                    │              │
│         └────────────────────┼────────────────────┘              │
│                              │                                   │
│                              ▼                                   │
│                    ┌─────────────────┐                          │
│                    │  Service DNS    │                          │
│                    │  kube-dns       │                          │
│                    │  10.96.0.10:53  │                          │
│                    └────────┬────────┘                          │
│                             │                                    │
│                             ▼                                    │
│                    ┌─────────────────┐                          │
│                    │   CoreDNS Pods  │                          │
│                    │   (Deployment)  │                          │
│                    └─────────────────┘                          │
│                                                                   │
└───────────────────────────────────────────────────────────────────┘

Flux de résolution

Quand un Pod veut contacter my-service.default.svc.cluster.local :

1. Le Pod lit /etc/resolv.conf → nameserver <IP du Service kube-dns>
2. La requête DNS part vers le Service kube-dns (souvent 10.96.0.10 sur kubeadm)
3. CoreDNS reçoit la requête via le plugin kubernetes qui publie les enregistrements DNS à partir des objets Kubernetes (Services, Endpoints)
4. CoreDNS renvoie l’adresse ClusterIP du Service
5. Le Pod peut maintenant contacter le Service

Format des noms DNS

Services

Type de nom	Format	Exemple
FQDN complet	<service>.<namespace>.svc.<cluster-domain>	nginx.default.svc.cluster.local
Dans le même namespace	<service>	nginx
Cross-namespace	<service>.<namespace>	nginx.production

Glissez pour voir

Raccourcis DNS

Depuis un Pod dans le namespace default, ces trois noms résolvent vers le même Service :

• nginx
• nginx.default
• nginx.default.svc.cluster.local

Pods

Kubernetes peut publier des enregistrements DNS pour les Pods, mais la résolution exacte dépend du DNS du cluster et de sa configuration. Pour CoreDNS, ce comportement dépend du plugin kubernetes et de ses options (notamment pods insecure).

Format si activé :

<pod-ip-avec-tirets>.<namespace>.pod.cluster.local

Exemple : 10-244-0-5.default.pod.cluster.local

Headless Services

Pour un Service headless (clusterIP: None), CoreDNS renvoie directement les IPs des Pods :

<pod-name>.<service>.<namespace>.svc.cluster.local

Utile pour les StatefulSets : mysql-0.mysql.default.svc.cluster.local

Vérifier que CoreDNS fonctionne

État du Deployment

kubectl get deployment coredns -n kube-system

NAME      READY   UP-TO-DATE   AVAILABLE   AGE
coredns   2/2     2            2           10d

État des Pods

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

NAME                       READY   STATUS    RESTARTS   AGE
coredns-5644d7b6d9-abcde   1/1     Running   0          10d
coredns-5644d7b6d9-fghij   1/1     Running   0          10d

Service kube-dns

kubectl get svc kube-dns -n kube-system

NAME       TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP,9153/TCP   10d

Adresse IP du Service DNS

L’IP 10.96.0.10 est typique sur les clusters kubeadm par défaut, mais elle dépend du Service CIDR configuré. Vérifiez toujours avec kubectl get svc kube-dns -n kube-system.

Configuration CoreDNS (Corefile)

CoreDNS est configuré via une ConfigMap nommée coredns dans kube-system.

Afficher la configuration actuelle

kubectl get configmap coredns -n kube-system -o yaml

Exemple courant de Corefile (kubeadm)

Le Corefile varie selon la distribution, la version et les personnalisations. Voici un exemple typique sur un cluster kubeadm :

.:53 {
    errors
    health {
       lameduck 5s
    }
    ready
    kubernetes cluster.local in-addr.arpa ip6.arpa {
       pods insecure
       fallthrough in-addr.arpa ip6.arpa
       ttl 30
    }
    prometheus :9153
    forward . /etc/resolv.conf {
       max_concurrent 1000
    }
    cache 30
    loop
    reload
    loadbalance
}

pods insecure

L’option pods insecure active une résolution DNS des Pods compatible avec l’ancien comportement de kube-dns. Ce n’est pas toujours nécessaire selon les besoins du cluster.

Explication des plugins

Plugin	Rôle
errors	Log les erreurs
health	Expose /health sur le port 8080
ready	Expose /ready sur le port 8181
kubernetes	Résout les noms du cluster Kubernetes
prometheus	Expose les métriques sur le port 9153
forward	Forwarde les requêtes externes vers les DNS upstream
cache	Cache les réponses (TTL 30 secondes)
loop	Détecte les boucles de forwarding
reload	Recharge la config quand la ConfigMap change
loadbalance	Répartit les réponses DNS (round-robin)

Glissez pour voir

Personnaliser CoreDNS

Ajouter un DNS externe personnalisé

Pour résoudre *.corp.example.com via un DNS interne d’entreprise :

kubectl edit configmap coredns -n kube-system

Ajoutez un bloc avant le bloc principal :

corp.example.com:53 {
    errors
    cache 30
    forward . 10.0.0.53
}
.:53 {
    # ... config par défaut
}

Ajouter des entrées statiques

Utilisez le plugin hosts pour des résolutions statiques :

.:53 {
    errors
    health
    hosts {
        192.168.1.100 legacy.internal
        192.168.1.101 oldserver.internal
        fallthrough
    }
    kubernetes cluster.local in-addr.arpa ip6.arpa {
       # ...
    }
    # ...
}

Redémarrage après modification

Après modification de la ConfigMap, CoreDNS recharge automatiquement grâce au plugin reload. Si ce n’est pas le cas, redémarrez les Pods :

kubectl rollout restart deployment coredns -n kube-system

Dépannage DNS (compétence CKA)

Test rapide avec un Pod de debug

1. Lancez un Pod de test

   kubectl run dnsutils --image=registry.k8s.io/e2e-test-images/agnhost:2.39 \
     --command -- sleep infinity

2. Testez la résolution

   kubectl exec -it dnsutils -- nslookup kubernetes.default

   Résultat attendu :

   Server:         10.96.0.10
   Address:        10.96.0.10#53
   
   Name:   kubernetes.default.svc.cluster.local
   Address: 10.96.0.1

3. Testez un Service spécifique

   kubectl exec -it dnsutils -- nslookup my-service.my-namespace

4. Nettoyez

   kubectl delete pod dnsutils

Vérifier /etc/resolv.conf dans un Pod

kubectl exec <pod-name> -- cat /etc/resolv.conf

Contenu attendu :

nameserver 10.96.0.10
search default.svc.cluster.local svc.cluster.local cluster.local
options ndots:5

Problèmes courants et solutions

Le Pod ne résout aucun nom

Symptôme :

kubectl exec mypod -- nslookup google.com
# timeout ou "server can't find"

Diagnostic :

# 1. CoreDNS fonctionne ?
kubectl get pods -n kube-system -l k8s-app=kube-dns

# 2. Service kube-dns existe ?
kubectl get svc kube-dns -n kube-system

# 3. Logs CoreDNS
kubectl logs -n kube-system -l k8s-app=kube-dns

Solutions possibles :

• Redémarrez CoreDNS : kubectl rollout restart deployment coredns -n kube-system
• Vérifiez les NetworkPolicies bloquant le port 53
• Vérifiez que le CNI est installé et fonctionnel

Résolution interne OK, externe KO

Symptôme :

kubectl exec mypod -- nslookup kubernetes.default
# OK

kubectl exec mypod -- nslookup google.com
# timeout

Diagnostic :

# Vérifiez le forward dans le Corefile
kubectl get configmap coredns -n kube-system -o yaml | grep forward

Solution : Vérifiez que /etc/resolv.conf du nœud contient des DNS valides, ou configurez un forward explicite :

forward . 8.8.8.8 8.8.4.4

Résolution très lente (timeout 5s)

Cause fréquente : Le paramètre ndots:5 fait essayer plusieurs suffixes avant la requête finale.

Solution : Pour une application qui fait beaucoup de requêtes externes, ajoutez un point final :

# Lent (essaie google.com.default.svc.cluster.local, etc.)
nslookup google.com

# Rapide (requête directe)
nslookup google.com.

Ou configurez le Pod avec un dnsConfig personnalisé :

apiVersion: v1
kind: Pod
metadata:
  name: fast-dns
spec:
  dnsConfig:
    options:
      - name: ndots
        value: "2"
  containers:
    - name: app
      image: nginx

Configurer le DNS des Pods

dnsPolicy

Le champ dnsPolicy contrôle la configuration DNS du Pod :

Valeur	Comportement
ClusterFirst (défaut)	Utilise CoreDNS pour tout
Default	Utilise le resolv.conf du nœud
ClusterFirstWithHostNet	Pour les Pods avec hostNetwork: true
None	Aucune config, à définir via dnsConfig

Glissez pour voir

Pods hostNetwork

Si votre Pod utilise hostNetwork: true, la policy ClusterFirst ne suffit pas. Utilisez ClusterFirstWithHostNet pour que le Pod puisse résoudre les noms de Services du cluster.

Exemple avec dnsConfig personnalisé

apiVersion: v1
kind: Pod
metadata:
  name: custom-dns
spec:
  dnsPolicy: "None"
  dnsConfig:
    nameservers:
      - 8.8.8.8
      - 8.8.4.4
    searches:
      - ns1.svc.cluster.local
      - my.dns.search.suffix
    options:
      - name: ndots
        value: "2"
      - name: edns0
  containers:
    - name: app
      image: nginx

Métriques et monitoring

CoreDNS expose des métriques Prometheus sur le port 9153 :

kubectl port-forward -n kube-system svc/kube-dns 9153:9153
curl http://localhost:9153/metrics

Métriques importantes :

Métrique	Description
coredns_dns_requests_total	Nombre total de requêtes
coredns_dns_responses_total	Réponses par code (NOERROR, NXDOMAIN, SERVFAIL)
coredns_dns_request_duration_seconds	Latence des requêtes
coredns_cache_hits_total	Hits du cache

Glissez pour voir

Scaling CoreDNS

Pour les grands clusters, augmentez le nombre de replicas :

kubectl scale deployment coredns -n kube-system --replicas=4

Ou utilisez l’Autoscaler DNS :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: coredns
  namespace: kube-system
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: coredns
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

Commandes CKA essentielles

# Vérifier l'état de CoreDNS
kubectl get deployment,pods,svc -n kube-system -l k8s-app=kube-dns

# Voir la configuration
kubectl get configmap coredns -n kube-system -o yaml

# Logs CoreDNS
kubectl logs -n kube-system -l k8s-app=kube-dns --tail=50

# Test DNS rapide (image officielle de debug)
kubectl run test-dns --rm -it --restart=Never \
  --image=registry.k8s.io/e2e-test-images/agnhost:2.39 \
  -- /agnhost dns-lookup kubernetes.default

# Redémarrer CoreDNS
kubectl rollout restart deployment coredns -n kube-system

Aller plus loin : NodeLocal DNSCache

Pour les grands clusters ou les applications sensibles à la latence DNS, Kubernetes propose NodeLocal DNSCache. Il place un cache DNS sur chaque nœud via un DaemonSet, réduisant la charge sur CoreDNS et les temps de résolution.

Consultez la documentation NodeLocal DNSCache pour la mise en place.

À retenir

1. CoreDNS est le DNS par défaut de Kubernetes depuis la v1.13
2. Service kube-dns expose CoreDNS (IP variable selon le Service CIDR, souvent 10.96.0.10 sur kubeadm)
3. Format DNS : <service>.<namespace>.svc.cluster.local
4. Corefile dans la ConfigMap coredns du namespace kube-system
5. Plugin forward gère les requêtes DNS externes
6. Test rapide avec l’image agnhost ou un Pod dnsutils
7. ndots:5 peut ralentir les requêtes externes (ajouter un . final)
8. hostNetwork nécessite ClusterFirstWithHostNet pour résoudre les Services

Prochaines étapes

Services Comprendre les Services Kubernetes

Troubleshooting Méthodologie de dépannage cluster

Network Policies Isolation réseau entre Pods

Debug Applications Diagnostiquer les problèmes applicatifs

×

📖 Voir la documentation →