Habilitación de la memoria caché de DNS NodeLocal

Habilite la memoria caché de DNS NodeLocal para uno o más nodos trabajadores en el clúster de Kubernetes.

Versión 1.35 y posteriores

NodeLocal DNS está activado por defecto en todos los nodos trabajadores. Siga estos pasos sólo si previamente desactivó NodeLocal DNS o si está añadiendo nuevos nodos de trabajo con NodeLocal DNS desactivado.

Versión 1.34 y anteriores

NodeLocal El DNS es opcional. Siga estos pasos para habilitarlo en sus nodos trabajadores.

Los pasos siguientes actualizan los pods de DNS que se ejecutan en nodos trabajadores específicos. También puede etiquetar la agrupación de nodos trabajadores de modo que los nodos futuros hereden la etiqueta.

Antes de empezar, actualice cualquier política de red de salida de DNS que se vea afectada por esta función, como las políticas que se basan en selectores de pod o de espacio de nombres para la salida de DNS.

kubectl get networkpolicy --all-namespaces -o yaml

1. Inicie una sesión en la cuenta. If applicable, target the appropriate resource group. Establezca el contexto para el clúster.

2. Si personaliza dominios de apéndice y servidores DNS en sentido ascendente para CoreDNS, también debe personalizar la memoria caché de DNS de NodeLocal con estos dominios de apéndice y servidores DNS en sentido ascendente.

3. Obtenga una lista de los nodos del clúster. Los pods del agente de almacenamiento en memoria caché de DNS NodeLocal forman parte de un conjunto de daemons que se ejecuta en cada nodo.

   kubectl get nodes
   

4. Añada la etiqueta ibm-cloud.kubernetes.io/node-local-dns-enabled=true al nodo trabajador. La etiqueta inicia el pod del agente de memoria caché de DNS en el nodo trabajador.

   1. Añada la etiqueta a uno o varios nodos trabajadores.

      • Para etiquetar todos los nodos trabajadores del clúster: añada la etiqueta a todas las agrupaciones de nodos trabajadores existentes.

      • Para etiquetar un nodo trabajador individual:

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

   2. Verifique que el nodo tiene la etiqueta comprobando que el campo NODE-LOCAL-DNS-ENABLED está establecido en true.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Salida de ejemplo
   
       ```sh {: screen}
       NAME          STATUS                      ROLES    AGE   VERSION       NODE-LOCAL-DNS-ENABLED
       10.xxx.xx.xxx Ready,SchedulingDisabled    <none>   28h   v1.35+IKS   true
       ```
   3. Verifique que el pod del agente de almacenamiento en memoria caché de DNS se está ejecutando en el nodo trabajador.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Salida de ejemplo
   
       ```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. Repita los pasos anteriores para cada nodo trabajador para habilitar la colocación en memoria caché de DNS.

Inhabilitación de la memoria caché de DNS NodeLocal

Puede inhabilitar la memoria caché de DNS NodeLocal para uno o para varios nodos trabajadores.

Versión 1.35 y posteriores

Para desactivar NodeLocal DNS, que está activado por defecto, añada la etiqueta ibm-cloud.kubernetes.io/node-local-dns-disabled=true a sus nodos trabajadores.

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

Versión 1.34 y anteriores

Para desactivar NodeLocal DNS, elimine la etiqueta ibm-cloud.kubernetes.io/node-local-dns-enabled de sus nodos trabajadores.

1. Inicie una sesión en la cuenta. If applicable, target the appropriate resource group. Establezca el contexto para el clúster.

2. Elimine la etiqueta ibm-cloud.kubernetes.io/node-local-dns-enabled del nodo trabajador. Esta acción finaliza el pod del agente de almacenamiento en memoria caché de DNS en el nodo trabajador.

   Ejecute el mandato siguiente para eliminar la etiqueta de todos los nodos de trabajador del clúster.

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

   Ejecute el mandato siguiente para eliminar la etiqueta de un nodo de trabajador individual.

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

   1. Verifique que la etiqueta se ha eliminado comprobando que el campo NODE-LOCAL-DNS-ENABLED está vacío.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Salida de ejemplo
   
       ```sh {: screen}
       NAME          STATUS                      ROLES    AGE   VERSION       NODE-LOCAL-DNS-ENABLED
       10.xxx.xx.xxx Ready,SchedulingDisabled    <none>   28h   v1.35+IKS   
       ```
   2. Verifique que el pod ya no se está ejecutando en el nodo en el que está inhabilitada la memoria caché de DNS. La salida no muestra ningún pod.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Salida de ejemplo
   
       ```sh {: screen}
       No resources found.
       ```
   

3. Repita los pasos anteriores para cada nodo trabajador para inhabilitar la colocación en memoria caché de DNS.

Edición del mapa de configuración node-local-dns para actualizaciones generales de configuración

Edite el mapa de configuración node-local-dns para personalizar la configuración de la memoria caché de DNS de NodeLocal.

Antes de empezar: Inicie una sesión en su cuenta. If applicable, target the appropriate resource group. Establezca el contexto para el clúster.

1. Verifique que el conjunto de daemons de memoria caché DNS de NodeLocal esté disponible.

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

   Salida de ejemplo

   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. Edite los valores predeterminados o añada Corefiles personalizados al mapa de configuración de memoria caché de DNS NodeLocal. Cada Corefile que importe debe utilizar la vía de acceso coredns. Para obtener más información, consulta la documentación de Kubernetes.

   Solo se admite un conjunto limitado de complementos para la caché de DNS NodeLocal.

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

   Salida de ejemplo

   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. Después de unos minutos, los pods de memoria caché de DNS NodeLocal captan los cambios del mapa de configuración.

Edición del mapa de configuración node-local-dns-config para ampliar con dominios de apéndice o servidores en sentido ascendente

Edite el mapa de configuración node-local-dns-config para ampliar la configuración de la memoria caché de DNS NodeLocal, por ejemplo para personalizar los dominios de apéndice o los servidores de DNS en sentido ascendente. Para obtener más información, consulta la documentación de Kubernetes.

Antes de empezar: Inicie una sesión en su cuenta. If applicable, target the appropriate resource group. Establezca el contexto para el clúster.

1. Verifique que el conjunto de daemons de memoria caché DNS de NodeLocal esté disponible.

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

   Salida de ejemplo

   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. Confirme que la memoria caché de DNS NodeLocal tenga un mapa de configuración.

   1. Determine si el mapa de configuración de memoria caché de DNS NodeLocal exista.

       kubectl get cm -n kube-system node-local-dns-config
       ```
       Salida de ejemplo cuando no hay un mapa de configuración
   
       ```sh {: screen}
       Error from server (NotFound): ConfigMaps "node-local-dns-config" not found
       ```
   2. Si el mapa de configuración no existe, cree un mapa de configuración de memoria caché de DNS de `NodeLocal`.
   
   ```sh {: pre}
       kubectl create cm -n kube-system node-local-dns-config
       ```
       Salida de ejemplo
   
       ```sh {: screen}
       configmap/node-local-dns-config created
       ```
   

3. Edite el mapa de configuración de memoria caché DNS NodeLocal. El mapa de configuración utiliza la sintaxis de KubeDNS para personalizar los dominios de apéndice y los servidores DNS en sentido ascendente. Para obtener más información, consulta la documentación de Kubernetes.

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

   Salida de ejemplo

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

4. Después de unos minutos, los pods de memoria caché de DNS NodeLocal captan los cambios del mapa de configuración.

Configuración de DNS con distinción de zonas

Realice el paso siguiente para configurar DNS con reconocimiento de zona en el clúster multizona.

1. Actualice cualquier política de red de salida de DNS que se vea afectada por el DNS sensible a la zona, como las políticas que se basan en selectores de pod o de espacio de nombres para la salida de DNS. Ejecuta el siguiente comando para obtener una lista de tus políticas de red.

   kubectl get networkpolicy --all-namespaces -o yaml
   

2. Etiquete el coredns ConfigMap en el espacio de nombres kube-system con 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. Renovar el maestro de clúster para desplegar los recursos DNS que tienen en cuenta las zonas.

   ibmcloud ks cluster master refresh -c CLUSTER_NAME_OR_ID
   

4. Espere a que finalice la operación de renovación; para ello revise el Estado del nodo maestro en los detalles del clúster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID
   

5. Si personaliza dominios de apéndice y servidores DNS en sentido ascendente para CoreDNS, también debe personalizar la memoria caché de DNS de NodeLocal con estos dominios de apéndice y servidores DNS en sentido ascendente.

6. Defina una variable de entorno para las zonas del clúster.

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

7. Inicie los pods de CoreDNS y del programa de escalado automático de CoreDNS en todas las zonas.

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

8. Compruebe que los pods de CoreDNS y del programa de escalado automático de CoreDNS se están ejecutando en todas las zonas.

   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. Inicie los pods de memoria caché de DNS NodeLocal en todos los nodos trabajadores.

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

10. Verifique que los pods de memoria caché de DNS NodeLocal se están ejecutando en todos los nodos trabajadores.

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

11. Etiquete sus agrupaciones de nodos trabajadores para que los nodos trabajadores futuros hereden la etiqueta ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true.

Inhabilitación y supresión de DNS con distinción de zonas

Para eliminar DNS con distinción de zonas, primero tiene que inhabilitar DNS con distinción de zonas cada zona del clúster multizonas. A continuación, suprima los recursos de DNS con distinción de zonas.

1. Elimine la etiqueta ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true de las agrupaciones de nodos trabajadores.

2. Defina una variable de entorno para las zonas del clúster.

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

3. Detenga los pods de memoria caché de DNS NodeLocal en todos los nodos trabajadores.

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

4. Detenga los pods del programa de escalado automático de CoreDNS en todas las zonas.

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

5. Compruebe que los pods del programa de escalado automático de CoreDNS ya no se están ejecutando en ninguna zona.

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

6. Detenga los pods de CoreDNS en todas las zonas.

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

7. Elimine la etiqueta ibm-cloud.kubernetes.io/deploy-zone-aware-dns=true del mapa de configuración coredns en el espacio de nombres kube-system.

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

8. Renueve el nodo maestro del clúster para suprimir los recursos de DNS con distinción de zonas.

   ibmcloud ks cluster master refresh --cluster CLUSTER_NAME_OR_ID
   

9. Espere a que finalice la operación de renovación; para ello revise el Estado del nodo maestro en los detalles del clúster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID