Principes et configuration du DNS - Container Compute Service

Les clusters Alibaba Cloud Container Compute Service (ACS) utilisent CoreDNS pour la résolution DNS. Cette rubrique explique le fonctionnement du DNS au sein d'un cluster et détaille la configuration de dnsPolicy pour répondre aux exigences de vos charges de travail.

Activer la résolution DNS dans votre cluster

La résolution DNS n'est pas activée par défaut sur les clusters ACS. Pour l'activer, sélectionnez CoreDNS lors de la création du cluster. CoreDNS est exposé dans le cluster sous la forme d'un Service nommé kube-dns dans le namespace kube-system.

Exécutez la commande suivante pour vérifier le Service kube-dns :

kubectl get svc kube-dns -n kube-system

Résultat attendu :

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

Pour plus d'informations sur la création d'un cluster ACS avec CoreDNS activé, consultez Créer un cluster ACS.

Fonctionnement de la résolution DNS dans les clusters ACS

Au démarrage d'un Pod, le kubelet configure ses paramètres DNS à l'aide de deux arguments :

--cluster-dns=<dns-service-ip> : adresse IP du serveur DNS du cluster.
--cluster-domain=<default-local-domain> : suffixe du nom de domaine de base.

Ces paramètres déterminent le contenu du fichier /etc/resolv.conf de chaque Pod :

nameserver xx.xx.0.10
search kube-system.svc.cluster.local svc.cluster.local cluster.local
options ndots:5

Paramètre	Description
`nameserver`	Adresse IP du serveur DNS.
`search`	Suffixes de domaine ajoutés aux noms courts lors des recherches DNS. Les clusters ACS incluent trois suffixes (`kube-system.svc.cluster.local`, `svc.cluster.local`, `cluster.local`), ce qui peut générer jusqu'à quatre requêtes DNS pour une seule recherche.
`options`	Options supplémentaires du résolveur sous forme de paires clé-valeur. La valeur par défaut `ndots:5` signifie qu'un nom de domaine contenant plus de points que la valeur `ndots` est traité comme un nom de domaine pleinement qualifié (FQDN) et résolu directement. Dans le cas contraire, les suffixes `search` sont ajoutés en premier.

Choisir une politique DNS

Définissez dnsPolicy dans la spécification du Pod pour contrôler la résolution des noms de domaine. Les clusters ACS prennent en charge les politiques suivantes :

Politique	Serveur DNS utilisé	Cas d'usage
`ClusterFirst`	CoreDNS (`kube-dns`)	Pods nécessitant un accès aux autres Services du cluster. Il s'agit de la valeur par défaut.
`None`	Défini par `dnsConfig`	Pods exigeant une configuration DNS entièrement personnalisée.
`Default`	Fichier `/etc/resolv.conf` du nœud (Alibaba Cloud DNS)	Pods n'accédant à aucun Service interne au cluster.

La politique Default n'est pas la politique DNS par défaut. Si dnsPolicy n'est pas spécifié, ClusterFirst s'applique.

Utiliser CoreDNS pour résoudre les noms de domaine internes au cluster

Définissez dnsPolicy: ClusterFirst pour les Pods qui communiquent avec d'autres Services du cluster. Ce comportement s'applique par défaut aux charges de travail ACS.

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

Personnaliser les paramètres DNS d'un Pod

Définissez dnsPolicy: None et fournissez un bloc dnsConfig pour contrôler intégralement les paramètres DNS d'un Pod. Lorsque dnsPolicy est définie sur None, spécifiez au moins un nameserver dans dnsConfig.

Le champ dnsConfig est facultatif et compatible avec toute dnsPolicy, pas uniquement None. Utilisez-le avec d'autres politiques pour ajouter des nameservers ou des domaines de recherche aux paramètres existants.

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"

Au démarrage du Pod, cette configuration génère le fichier /etc/resolv.conf suivant :

nameserver 169.254.xx.xx
search default.svc.cluster.local svc.cluster.local cluster.local
options ndots:2

Le tableau suivant décrit les champs de dnsConfig :

Champ	Description
`nameservers`	Liste des adresses IP des serveurs DNS pour le Pod. Trois adresses IP maximum sont autorisées. Si `dnsPolicy` est définie sur `None`, au moins une adresse est requise. Les doublons sont supprimés.
`searches`	Liste des domaines de recherche DNS pour la résolution des noms d'hôte. Six domaines maximum sont autorisés. Ils s'ajoutent à la liste de base dérivée de la politique DNS. Les doublons sont supprimés.
`options`	Liste des options du résolveur, chacune comportant un `name` (obligatoire) et une `value` (facultative). Ces options fusionnent avec celles générées par la politique DNS. Les doublons sont supprimés.

Utiliser le DNS au niveau du nœud sans CoreDNS

Si vos Pods n'accèdent à aucun Service du cluster ACS, définissez dnsPolicy: Default. Alibaba Cloud DNS gère alors la résolution via le fichier /etc/resolv.conf du nœud, sans intervention de CoreDNS.

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

Mapper des noms d'hôte statiques à des adresses IP

Pour ajouter des mappages statiques entre noms d'hôte et adresses IP pour un Pod spécifique, ajoutez le champ hostAliases à la spécification du Pod. Le kubelet gère le fichier /etc/hosts du Pod et y inscrit ces entrées au démarrage.

Avertissement

Ne modifiez pas manuellement le fichier /etc/hosts dans un conteneur en cours d'exécution. Le kubelet écrase ce fichier lors du redémarrage du conteneur, ce qui entraîne la perte des modifications manuelles.

Pour appliquer des mappages statiques à tous les Pods du cluster plutôt qu'à un seul Pod, activez le plug-in hosts de CoreDNS. Consultez Configurer les extensions CoreDNS.

L'exemple suivant mappe foo.local, bar.local et foo.remote à des adresses IP statiques :

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"

Une fois le Pod démarré, le fichier /etc/hosts contient les éléments suivants :

# Kubernetes-managed hosts file.
127.0.**.**	localhost
10.200.**.**	hostaliases-pod

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

Étapes suivantes

Configurer les extensions CoreDNS