Activation du cache DNS NodeLocal

Activez le cache DNS NodeLocal pour un ou plusieurs des noeuds worker figurant dans votre cluster Kubernetes.

1.35 s de version et versions ultérieures

NodeLocal Le DNS est activé par défaut sur tous les nœuds de travail. Suivez ces étapes uniquement si vous avez désactivé NodeLocal DNS ou si vous ajoutez de nouveaux nœuds de travail avec NodeLocal DNS désactivé.

1.34 s de version et versions antérieures

NodeLocal Le DNS est opt-in. Suivez les étapes suivantes pour l'activer sur vos nœuds de travail.

Les étapes suivantes mettent à jour les pods DNS qui s'exécutent sur des noeuds worker particuliers. Vous pouvez également affecter un libellé au pool de noeuds worker pour que de futurs noeuds héritent de ce libellé.

Avant de commencer, mettez à jour toutes les politiques de réseau de sortie DNS concernées par cette fonctionnalité, telles que celles qui s'appuient sur des sélecteurs de pod ou d'espace de noms pour la sortie DNS.

kubectl get networkpolicy --all-namespaces -o yaml

1. Connectez-vous à votre compte. Le cas échéant, ciblez le groupe de ressources approprié. Définissez le contexte de votre cluster.

2. Si vous avez personnalisé les domaines de module de remplacement et les serveurs DNS en amont pour CoreDNS, vous devez également personnaliser le cache DNS NodeLocal avec ces domaines de module de remplacement et ces serveurs DNS en amont.

3. Répertoriez les noeuds présents dans votre cluster. Les pods d'agent de mise en cache DNS NodeLocal font partie d'un ensemble de démons qui s'exécutent sur chaque noeud.

   kubectl get nodes
   

4. Ajoutez le libellé ibm-cloud.kubernetes.io/node-local-dns-enabled=true au noeud worker. Le libellé démarre le pod d'agent de mise en cache DNS sur le noeud worker.

   1. Ajoutez le libellé à un ou plusieurs noeuds worker.

      • Pour libeller tous les noeuds worker du cluster : Ajoutez le libellé à tous les pools de noeuds worker existants.

      • Pour libeller un noeud worker en particulier :

        kubectl label node <node_name> --overwrite "ibm-cloud.kubernetes.io/node-local-dns-enabled=true"
        

   2. Vérifiez que le noeud comporte le libellé en vous assurant que la zone NODE-LOCAL-DNS-ENABLED a pour valeur true.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Exemple de sortie
   
       ```sh {: screen}
       NAME          STATUS                      ROLES    AGE   VERSION       NODE-LOCAL-DNS-ENABLED
       10.xxx.xx.xxx Ready,SchedulingDisabled    <none>   28h   v1.35+IKS   true
       ```
   3. Assurez-vous que le pod d'agent de mise en cache DNS s'exécute sur le noeud worker.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Exemple de sortie
   
       ```sh {: screen}
       NAME                   READY   STATUS    RESTARTS   AGE   IP            NODE          NOMINATED NODE   READINESS GATES
       node-local-dns-pvnjn   1/1     Running   0          1m    10.xxx.xx.xxx   10.xxx.xx.xxx  <none>           <none>
       ```
   

5. Répétez les étapes précédentes pour chaque noeud worker afin d'activer la mise en cache DNS.

Désactivation du cache DNS NodeLocal

Vous pouvez désactiver le cache DNS NodeLocal pour un ou plusieurs noeuds worker.

1.35 s de version et versions ultérieures

Pour désactiver NodeLocal DNS, qui est activé par défaut, ajoutez l'étiquette ibm-cloud.kubernetes.io/node-local-dns-disabled=true à vos nœuds de travail.

kubectl label node --all --overwrite "ibm-cloud.kubernetes.io/node-local-dns-disabled=true"

1.34 s de version et versions antérieures

Pour désactiver NodeLocal DNS, supprimez l'étiquette ibm-cloud.kubernetes.io/node-local-dns-enabled de vos nœuds de travail.

1. Connectez-vous à votre compte. Le cas échéant, ciblez le groupe de ressources approprié. Définissez le contexte de votre cluster.

2. Retirez le libellé ibm-cloud.kubernetes.io/node-local-dns-enabled du noeud worker. Cette action met fin au pod de l'agent de mise en cache DNS sur le noeud worker.

   Pour retirer le libellé de tous les noeuds worker du cluster, exécutez la commande suivante :

   kubectl label node --all --overwrite "ibm-cloud.kubernetes.io/node-local-dns-enabled-"
   

   Pour retirer le libellé d'un noeud worker en particulier, exécutez la commande suivante :

   kubectl label node <node_name> "ibm-cloud.kubernetes.io/node-local-dns-enabled-"
   

   1. Vérifiez que le libellé est retiré en vous assurant que la zone NODE-LOCAL-DNS-ENABLED est vide.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Exemple de sortie
   
       ```sh {: screen}
       NAME          STATUS                      ROLES    AGE   VERSION       NODE-LOCAL-DNS-ENABLED
       10.xxx.xx.xxx Ready,SchedulingDisabled    <none>   28h   v1.35+IKS   
       ```
   2. Vérifiez que le pod ne s'exécute plus sur le noeud sur lequel le cache DNS est désactivé. La sortie ne contient aucun pod.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Exemple de sortie
   
       ```sh {: screen}
       No resources found.
       ```
   

3. Répétez les étapes précédentes pour chaque noeud worker afin de désactiver la mise en cache DNS.

Edition de la mappe de configuration node-local-dns pour les mises à jour de configuration générales

Editez la mappe de configuration node-local-dns pour personnaliser la configuration du cache DNS NodeLocal.

Avant de commencer : Connectez-vous à votre compte. Le cas échéant, ciblez le groupe de ressources approprié. Définissez le contexte de votre cluster.

1. Vérifiez que le démon du cache DNS NodeLocal est disponible.

   kubectl get ds -n kube-system node-local-dns
   

   Exemple de sortie

   NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR                                         AGE
   node-local-dns   4         4         4       4            4           ibm-cloud.kubernetes.io/node-local-dns-enabled=true   82d
   

2. Editez les paramètres par défaut ou ajouter des fichiers Corefile personnalisés à la mappe de configuration du cache DNS NodeLocal. Chaque fichier Corefile que vous importez doit utiliser le chemin coredns. Pour plus d’informations, consultez la documentation d’ Kubernetes.

   Seul un ensemble limité de plug-ins est pris en charge pour le cache DNS NodeLocal.

   kubectl edit configmap -n kube-system node-local-dns
   

   Exemple de sortie

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: node-local-dns
     namespace: kube-system
   data:
     Corefile: |
       # Add your NodeLocal DNS customizations as import files under ./coredns directory.
       # Refer to /docs/containers?topic=containers-cluster_dns for details.
       import ./coredns/<MyCorefile>
       cluster.local:53 abc.com:53 {
           errors
           cache {
                   success 9984 30
                   denial 9984 5
           }
           reload
           loop
           bind 169.254.20.10 172.21.0.10
           forward . __PILLAR__CLUSTER__DNS__ {
                   force_tcp
           }
           prometheus :9253
           health 169.254.20.10:8080
           }
       in-addr.arpa:53 {
           errors
           cache 30
           reload
           loop
           bind 169.254.20.10 172.21.0.10
           forward . __PILLAR__CLUSTER__DNS__ {
                   force_tcp
           }
           prometheus :9253
           }
       ip6.arpa:53 {
           errors
           cache 30
           reload
           loop
           bind 169.254.20.10 172.21.0.10
           forward . __PILLAR__CLUSTER__DNS__ {
                   force_tcp
           }
           prometheus :9253
           }
       .:53 {
           errors
           cache 30 {
                 disable success cluster.local
                 disable denial cluster.local
           }
           reload
           loop
           bind 169.254.20.10 172.21.0.10
           forward . __PILLAR__UPSTREAM__SERVERS__ {
                   force_tcp
           }
           prometheus :9253
           }
     <MyCorefile>: |
       # Add custom corefile content ...
   

3. Au bout de quelques minutes, les pods de cache DNS NodeLocal récupèrent les modifications de mappe de configuration.

Edition de la mappe de configuration node-local-dns-config pour une extension à l'aide de domaines de module de remplacement ou de serveurs en amont

Editez la mappe de configuration node-local-dns-config pour étendre la configuration du cache DNS NodeLocal, par exemple en personnalisant les domaines de module de remplacement ou les serveurs DNS en amont. Pour plus d’informations, consultez la documentation d’ Kubernetes.

Avant de commencer : Connectez-vous à votre compte. Le cas échéant, ciblez le groupe de ressources approprié. Définissez le contexte de votre cluster.

1. Vérifiez que le démon du cache DNS NodeLocal est disponible.

   kubectl get ds -n kube-system node-local-dns
   

   Exemple de sortie

   NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR                                         AGE
   node-local-dns   4         4         4       4            4           ibm-cloud.kubernetes.io/node-local-dns-enabled=true   82d
   

2. Confirmez que le cache DNS NodeLocal comporte une mappe de configuration.

   1. Déterminez si la mappe de configuration du cache DNS NodeLocal existe.

       kubectl get cm -n kube-system node-local-dns-config
       ```
       Exemple de sortie s'il n'existe aucune mappe de configuration
   
       ```sh {: screen}
       Error from server (NotFound): ConfigMaps "node-local-dns-config" not found
       ```
   2. Si la mappe de configuration n'existe pas, créez une mappe de configuration de cache DNS `NodeLocal`.
   
   ```sh {: pre}
       kubectl create cm -n kube-system node-local-dns-config
       ```
       Exemple de sortie
   
       ```sh {: screen}
       configmap/node-local-dns-config created
       ```
   

3. Editez la mappe de configuration du cache DNS NodeLocal. La mappe de configuration utilise la syntaxe KubeDNS pour personnaliser les domaines de module de remplacement et les serveurs DNS en amont. Pour plus d'informations, consultez la documentation d' Kubernetes.

   kubectl edit cm -n kube-system node-local-dns-config
   

   Exemple de sortie

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: node-local-dns-config
     namespace: kube-system
   data:
     stubDomains: |
         {"abc.com" : ["1.2.3.4"]}
   

4. Au bout de quelques minutes, les pods de cache DNS NodeLocal récupèrent les modifications de mappe de configuration.

Configuration du service DNS reconnaissant les zones

Procédez comme suit pour configurer un serveur de noms de domaine prenant en compte les zones dans votre cluster multizone.

1. Mettez à jour toutes les politiques de réseau de sortie DNS concernées par le DNS sensible à la zone, telles que les politiques qui s'appuient sur des sélecteurs de pod ou d'espace de noms pour la sortie DNS. Exécutez la commande suivante pour obtenir la liste de vos politiques réseau.

   kubectl get networkpolicy --all-namespaces -o yaml
   

2. Libellez coredns ConfigMap dans l'espace de nom kube-system avec ibm-cloud.kubernetes.io/deploy-zone-aware-dns=true.

   kubectl label cm -n kube-system coredns --overwrite "ibm-cloud.kubernetes.io/deploy-zone-aware-dns=true"
   

3. Actualisez le maître cluster pour déployer les ressources DNS sensibles aux zones.

   ibmcloud ks cluster master refresh -c CLUSTER_NAME_OR_ID
   

4. Surveillez l'achèvement de l'opération d'actualisation en examinant la zone Santé du maître dans les détails du cluster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID
   

5. Si vous avez personnalisé les domaines de module de remplacement et les serveurs DNS en amont pour CoreDNS, vous devez également personnaliser le cache DNS NodeLocal avec ces domaines de module de remplacement et ces serveurs DNS en amont.

6. Définissez une variable d'environnement pour les zones du cluster.

   ZONES=$(kubectl get nodes --no-headers --ignore-not-found=true -o jsonpath='{range .items[*]}{.metadata.labels.topology\.kubernetes\.io/zone}{"\n"}{end}' | uniq)
   

7. Démarrez les pods de CoreDNS et du programme de mise à l'échelle automatique de CoreDNS dans toutes les zones.

   for ZONE in ${ZONES}; do
       kubectl scale deployment -n kube-system "coredns-autoscaler-${ZONE}" --replicas=1
   done
   

8. Vérifiez que les pods de CoreDNS et du programme de mise à l'échelle automatique de CoreDNS sont en cours d'exécution dans toutes les zones.

   for ZONE in ${ZONES}; do
       kubectl get pods -n kube-system -l "k8s-app=coredns-autoscaler-${ZONE}" -o wide
       kubectl get pods -n kube-system -l "k8s-app=coredns-${ZONE}" -o wide
   done
   

9. Démarrez les pods du cache DNS NodeLocal sur tous les noeuds worker.

   kubectl label nodes --all --overwrite "ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true"
   

10. Vérifiez que les pods du cache DNS NodeLocal sont en cours d'exécution sur tous les noeuds worker.

    for ZONE in ${ZONES}; do
        kubectl get pods -n kube-system -l "k8s-app=node-local-dns-${ZONE}" -o wide
    done
    

11. Libellez vos pools de noeuds worker de sorte que les futurs noeuds worker héritent du libellé ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true.

Désactivation et suppression du service DNS reconnaissant les zones

Pour retirer le service DNS reconnaissant les zones, vous devez d'abord le désactiver dans chaque zone de votre cluster multizone. Ensuite, vous pouvez supprimer les ressources du service DNS reconnaissant les zones.

1. Supprimer le. ibm-cloud.kubernetes.io/zone-aware-dns-enabled=trueétiquette de vos pools de travailleurs

2. Définissez une variable d'environnement pour les zones du cluster.

   ZONES=$(kubectl get nodes --no-headers --ignore-not-found=true -o jsonpath='{range .items[*]}{.metadata.labels.topology\.kubernetes\.io/zone}{"\n"}{end}' | uniq)
   

3. Arrêtez les pods du cache DNS NodeLocal sur tous les noeuds worker.

   kubectl label nodes --all --overwrite "ibm-cloud.kubernetes.io/zone-aware-dns-enabled-"
   

4. Arrêtez les pods du programme de mise à l'échelle automatique de CoreDNS dans toutes les zones.

   for ZONE in ${ZONES}; do
       kubectl scale deployment -n kube-system "coredns-autoscaler-${ZONE}" --replicas=0
   done
   

5. Vérifiez que les pods du programme de mise à l'échelle automatique de CoreDNS ne sont plus en cours d'exécution dans toutes les zones.

   for ZONE in ${ZONES}; do
       kubectl get pods -n kube-system -l "k8s-app=coredns-autoscaler-${ZONE}"
   done
   

6. Arrêtez les pods de CoreDNS dans toutes les zones.

   for ZONE in ${ZONES}; do
       kubectl scale deployment -n kube-system "coredns-${ZONE}" --replicas=0
   done
   

7. Retirez le libellé ibm-cloud.kubernetes.io/deploy-zone-aware-dns=true de la mappe de configuration coredns dans l'espace de noms kube-system.

   kubectl label cm -n kube-system coredns --overwrite "ibm-cloud.kubernetes.io/deploy-zone-aware-dns-"
   

8. Actualisez le maître cluster sur les ressources de service DNS reconnaissant les zones qui sont supprimées.

   ibmcloud ks cluster master refresh --cluster CLUSTER_NAME_OR_ID
   

9. Surveillez l'achèvement de l'opération d'actualisation en examinant la zone Santé du maître dans les détails du cluster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID