Tous les produits
Search
Centre de documentation

Container Service for Kubernetes:Configure pod DNS policies and domain name resolution

Dernière mise à jour :Aug 11, 2026

Définissez le paramètre dnsPolicy pour contrôler le comportement DNS des pods, et utilisez le champ hostAliases pour mapper des domaines vers des adresses IP fixes.

Prérequis

Fonctionnement de CoreDNS dans ACK

ACK déploie CoreDNS dans chaque cluster. Un service nommé kube-dns l'expose pour les requêtes DNS des pods. Par défaut, deux pods coredns assurent le backend.

Inspectez les composants DNS de votre cluster :

# Check the kube-dns Service
kubectl get svc kube-dns -n kube-system

# Check the coredns Deployment
kubectl get deployment coredns -n kube-system

Consultez la section Aperçu du DNS.

Définir une stratégie DNS pour un pod

Le paramètre dnsPolicy contrôle la manière dont un pod résout les noms de domaine. ACK prend en charge quatre stratégies :

Stratégie Comportement
ClusterFirst Le pod utilise CoreDNS. Le fichier /etc/resolv.conf pointe vers le service kube-dns. Il s'agit de la stratégie par défaut.
None Le pod ignore les paramètres DNS du cluster. Utilisez le champ dnsConfig pour des paramètres personnalisés ; sans celui-ci, aucune résolution de nom n'est possible.
Default Le pod hérite des paramètres DNS de son nœud. Dans ACK, les nœuds sont des instances ECS ; le pod utilise donc le fichier /etc/resolv.conf du nœud, qui pointe vers le DNS d'Alibaba Cloud. CoreDNS est contourné.
ClusterFirstWithHostNet Destinée aux pods utilisant hostNetwork. Sans cette stratégie, un pod hostNetwork utilise par défaut la stratégie Default et ne peut pas atteindre les services du cluster.
La stratégie Default n'est pas la stratégie par défaut. Si vous omettez le paramètre dnsPolicy , le pod utilise la stratégie ClusterFirst .

Utiliser CoreDNS pour résoudre les noms de domaine

Utilisez la stratégie ClusterFirst (par défaut) lorsque les pods doivent accéder à d'autres services du cluster.

Définissez le paramètre dnsPolicy: ClusterFirst dans la spécification du pod :

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: ClusterFirst

Appliquez le manifeste et vérifiez la résolution DNS :

kubectl apply -f pod.yaml

# Verify that the pod resolves cluster Services correctly
kubectl exec alpine -- nslookup kubernetes.default

Personnaliser les paramètres DNS d'un pod

Utilisez la stratégie dnsPolicy: None pour contrôler entièrement le serveur DNS et les domaines de recherche d'un pod.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: None
  dnsConfig:
    nameservers: ["169.254.xx.xx"]
    searches:
    - default.svc.cluster.local
    - svc.cluster.local
    - cluster.local
    options:
    - name: ndots
      value: "2"

Le champ dnsConfig accepte les propriétés suivantes :

  • nameservers : adresses IP des serveurs DNS pour le pod. Limité à trois serveurs. Requis lorsque le paramètre dnsPolicy est défini sur None ; facultatif dans les autres cas. Fusionné avec les serveurs de noms générés par la stratégie ; les doublons sont supprimés.

  • searches : domaines de recherche DNS pour la recherche de noms d'hôte. Facultatif. Limité à six domaines. Fusionné avec les domaines de recherche générés par la stratégie ; les doublons sont supprimés. Seul le premier domaine est essayé si le serveur DNS est inaccessible.

  • options : objets comprenant un champ obligatoire name et un champ facultatif value. Fusionné avec les options générées par la stratégie ; les doublons sont supprimés. Consultez la section Politiques de résolution et de mise en cache DNS.

Appliquez le manifeste et vérifiez la configuration :

kubectl apply -f pod.yaml

# Check the DNS configuration inside the pod
kubectl exec alpine -- cat /etc/resolv.conf

Consultez la documentation DNS for Services and Pods.

Utiliser les paramètres DNS du nœud

Utilisez la stratégie dnsPolicy: Default lorsque les pods n'ont pas besoin d'accéder aux services du cluster et doivent effectuer la résolution via le DNS d'Alibaba Cloud plutôt que via CoreDNS.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: Default

Appliquez le manifeste et vérifiez la configuration :

kubectl apply -f pod.yaml

# Confirm the pod inherits the node's resolv.conf
kubectl exec alpine -- cat /etc/resolv.conf

Permettre aux pods hostNetwork d'atteindre les services du cluster

Les pods configurés avec hostNetwork: true utilisent par défaut la stratégie DNS Default et ne peuvent pas atteindre les services du cluster par leur nom. Définissez le paramètre dnsPolicy: ClusterFirstWithHostNet pour rétablir la résolution DNS du cluster.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  hostNetwork: true
  dnsPolicy: ClusterFirstWithHostNet
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine

Appliquez le manifeste et vérifiez la résolution :

kubectl apply -f pod.yaml

# Verify that the pod resolves cluster Services correctly
kubectl exec alpine -- nslookup kubernetes.default

Mapper des noms de domaine vers des adresses IP spécifiques

Deux méthodes sont disponibles :

Ajouter des alias d'hôte à un pod

Le champ hostAliases ajoute des entrées au fichier /etc/hosts d'un pod après l'initialisation par Kubernetes.

Avertissement

Ne modifiez pas directement le fichier /etc/hosts. Kubelet gère ce fichier et écrase les modifications manuelles au démarrage ou au redémarrage du pod.

apiVersion: v1
kind: Pod
metadata:
  name: hostaliases-pod
spec:
  hostAliases:
  - ip: "127.0.**.**"
    hostnames:
    - "foo.local"
    - "bar.local"
  - ip: "10.1.**.**"
    hostnames:
    - "foo.remote"
  containers:
  - name: cat-hosts
    image: busybox:1.28
    command:
    - cat
    args:
    - "/etc/hosts"

Après l'initialisation, le fichier /etc/hosts contient les entrées gérées par Kubernetes, suivies de vos alias :

# Kubernetes-managed hosts file.
127.0.**.**	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
fe00::0	ip6-mcastprefix
fe00::1	ip6-allnodes
fe00::2	ip6-allrouters
10.200.**.**	hostaliases-pod

# Entries added by HostAliases.
127.0.**.**	foo.local	bar.local
10.1.**.**	foo.remote

Appliquez le manifeste et vérifiez que les alias se résolvent correctement :

kubectl apply -f hostaliases-pod.yaml

# Check that the aliases appear in /etc/hosts
kubectl exec hostaliases-pod -- cat /etc/hosts

# Verify resolution
kubectl exec hostaliases-pod -- nslookup foo.local

Étapes suivantes