Ativar o cache DNS do NodeLocal

Ative o cache DNS do NodeLocal para um ou mais nós do trabalhador em seu cluster Kubernetes.

Versão 1.35 e e posteriores

NodeLocal O DNS é ativado por padrão em todos os nós de trabalho. Siga estas etapas somente se você tiver desativado anteriormente o NodeLocal DNS ou se estiver adicionando novos nós de trabalho com o NodeLocal DNS desativado.

Versão 1.34 e e anteriores

NodeLocal O DNS é opcional. Siga estas etapas para ativá-lo em seus nós de trabalho.

As etapas a seguir atualizam os pods DNS executados em nós do trabalhador específicos. Também é possível rotular o conjunto de trabalhadores para que nós futuros herdem o rótulo.

Antes de começar, atualize todas as políticas de rede de saída de DNS afetadas por esse recurso, como as políticas que dependem de seletores de pod ou namespace para a saída de DNS.

kubectl get networkpolicy --all-namespaces -o yaml

1. Efetue login na sua conta. If applicable, target the appropriate resource group. Configure o contexto para o seu cluster.

2. Se você tiver customizado domínios stub e servidores DNS de envio de dados para CoreDNS, deve-se também customizar o cache DNS NodeLocal com esses domínios stub e servidores DNS de envio de dados.

3. Liste os nós em seu cluster. Os pods do agente de armazenamento em cache DNS do NodeLocal fazem parte de um conjunto de daemon executado em cada nó.

   kubectl get nodes
   

4. Inclua o rótulo ibm-cloud.kubernetes.io/node-local-dns-enabled=true no nó do trabalhador. O rótulo inicia o pod do agente de armazenamento em cache DNS no nó do trabalhador.

   1. Inclua o rótulo em um ou mais nós do trabalhador.

      • Para rotular todos os nós do trabalhador no cluster: inclua o rótulo em todos os conjuntos de trabalhadores existentes.

      • Para rotular um nó do trabalhador individual:

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

   2. Verifique se o nó tem o rótulo verificando se o campo NODE-LOCAL-DNS-ENABLED está configurado como true.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Saída de exemplo
   
       ```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 se o pod do agente de armazenamento em cache DNS está em execução no nó do trabalhador.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Saída de exemplo
   
       ```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 as etapas anteriores para cada nó do trabalhador para ativar o armazenamento em cache DNS.

Desativar o cache DNS do NodeLocal

É possível desativar o cache DNS do NodeLocal para um ou mais nós do trabalhador.

Versão 1.35 e e posteriores

Para desativar o DNS NodeLocal, que está ativado por padrão, adicione o rótulo ibm-cloud.kubernetes.io/node-local-dns-disabled=true aos seus nós de trabalho.

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

Versão 1.34 e e anteriores

Para desativar o DNS NodeLocal, remova o rótulo ibm-cloud.kubernetes.io/node-local-dns-enabled dos nós de trabalho.

1. Efetue login na sua conta. If applicable, target the appropriate resource group. Configure o contexto para o seu cluster.

2. Remova o rótulo ibm-cloud.kubernetes.io/node-local-dns-enabled do nó do trabalhador. Essa ação finaliza o pod do agente de armazenamento em cache DNS no nó do trabalhador.

   Execute o comando a seguir para remover o rótulo de todos os nós do trabalhador no cluster.

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

   Execute o comando a seguir para remover o rótulo de um nó do trabalhador individual.

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

   1. Verifique se o rótulo foi removido consultando se o campo NODE-LOCAL-DNS-ENABLED está vazio.

       kubectl get nodes -L "ibm-cloud.kubernetes.io/node-local-dns-enabled"
       ```
       Saída de exemplo
   
       ```sh {: screen}
       NAME          STATUS                      ROLES    AGE   VERSION       NODE-LOCAL-DNS-ENABLED
       10.xxx.xx.xxx Ready,SchedulingDisabled    <none>   28h   v1.35+IKS   
       ```
   2. Verifique se o pod não está mais em execução no nó no qual o cache DNS foi desativado. A saída não mostra pods.
   
   ```sh {: pre}
       kubectl get pods -n kube-system -l k8s-app=node-local-dns -o wide
       ```
       Saída de exemplo
   
       ```sh {: screen}
       No resources found.
       ```
   

3. Repita as etapas anteriores para cada nó do trabalhador para desativar o armazenamento em cache do DNS.

Editando o configmap node-local-dns para atualizações de configuração geral

Edite o configmap node-local-dns para customizar a configuração de cache de DNS NodeLocal.

Antes de iniciar: efetue login na sua conta. If applicable, target the appropriate resource group. Configure o contexto para o seu cluster.

1. Verifique se o conjunto de daemons do cache DNS do NodeLocal está disponível.

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

   Saída de exemplo

   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 as configurações padrão ou inclua os Arquivos principais customizados no configmap de cache de DNS NodeLocal. Cada Arquivo principal importado deve usar o caminho coredns. Para obter mais informações, consulte a Documentação do Kubernetes.

   Somente um conjunto limitado de plug-ins é suportado para o cache de DNS do NodeLocal.

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

   Saída de exemplo

   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. Após alguns minutos, os pods do cache DNS do NodeLocal assimilam as mudanças do mapa de configuração.

Editando o configmap node-local-dns-config para estender com domínios de stub ou servidores de envio de dados

Edite o configmap node-local-dns-config para estender a configuração de cache de DNS NodeLocal, como por meio da customização de domínios de stub ou de servidores DNS de envio de dados. Para obter mais informações, consulte a Documentação do Kubernetes.

Antes de iniciar: efetue login na sua conta. If applicable, target the appropriate resource group. Configure o contexto para o seu cluster.

1. Verifique se o conjunto de daemons do cache DNS do NodeLocal está disponível.

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

   Saída de exemplo

   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 se o cache DNS do NodeLocal tem um mapa de configuração.

   1. Determine se o mapa de configuração do cache DNS do NodeLocal existe.

       kubectl get cm -n kube-system node-local-dns-config
       ```
       Saída de exemplo se nenhum configmap existir
   
       ```sh {: screen}
       Error from server (NotFound): ConfigMaps "node-local-dns-config" not found
       ```
   2. Se o mapa de configuração não existir, crie um mapa de configuração do cache DNS do `NodeLocal`.
   
   ```sh {: pre}
       kubectl create cm -n kube-system node-local-dns-config
       ```
       Saída de exemplo
   
       ```sh {: screen}
       configmap/node-local-dns-config created
       ```
   

3. Edite o mapa de configuração do cache DNS do NodeLocal. O mapa de configuração usa a sintaxe do KubeDNS para customizar domínios stub e servidores DNS de envio de dados. Para obter mais informações, consulte a Documentação do Kubernetes.

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

   Saída de exemplo

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

4. Após alguns minutos, os pods do cache DNS do NodeLocal assimilam as mudanças do mapa de configuração.

Configurando o DNS com reconhecimento de zona

Conclua a etapa a seguir para configurar o DNS com reconhecimento de zona em seu cluster multizona

1. Atualize todas as políticas de rede de saída de DNS afetadas pelo DNS sensível à zona, como as políticas que dependem de seletores de pod ou namespace para a saída de DNS. Execute o comando a seguir para obter uma lista das suas políticas de rede.

   kubectl get networkpolicy --all-namespaces -o yaml
   

2. Rotule o coredns ConfigMap no namespace do kube-system com 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. Atualize o cluster mestre para implementar os recursos de DNS com reconhecimento de zona

   ibmcloud ks cluster master refresh -c CLUSTER_NAME_OR_ID
   

4. Veja se a operação de atualização foi concluída revisando o Funcionamento do mestre nos detalhes do cluster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID
   

5. Se você tiver customizado domínios stub e servidores DNS de envio de dados para CoreDNS, deve-se também customizar o cache DNS NodeLocal com esses domínios stub e servidores DNS de envio de dados.

6. Configure uma variável de ambiente para as zonas do 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. Inicie os pods de ajustador automático de escala CoreDNS e CoreDNS em todas as zonas.

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

8. Verifique se os pods de ajustador automático de escala CoreDNS e CoreDNS estão em execução em todas as 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 os pods de cache DNS do NodeLocal em todos os nós dos trabalhadores.

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

10. Verifique se os pods de cache DNS do NodeLocal estão em execução em todos os nós dos trabalhadores.

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

11. Rotule os seus conjuntos de trabalhadores para que futuros nós do trabalhador herdem o rótulo ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true.

Desativando e excluindo o DNS com reconhecimento de zona

Para remover o DNS com reconhecimento de zona, deve-se primeiro desativar o DNS com reconhecimento de zona em cada zona do seu cluster multizona. Em seguida, exclua os recursos DNS com reconhecimento de zona.

1. Remova o rótulo ibm-cloud.kubernetes.io/zone-aware-dns-enabled=true dos seus conjuntos de trabalhadores.

2. Configure uma variável de ambiente para as zonas no 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. Pare os pods de cache DNS do NodeLocal em todos os nós do trabalhador.

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

4. Pare os pods de ajustador automático de escala do CoreDNS em todas as zonas.

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

5. Verifique se os pods do ajustador automático de escala do CoreDNS não estão mais em execução em todas as zonas.

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

6. Pare os pods do CoreDNS em todas as zonas.

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

7. Remova o rótulo ibm-cloud.kubernetes.io/deploy-zone-aware-dns=true do configmap coredns no namespace kube-system.

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

8. Atualize o cluster mestre para excluir os recursos DNS com reconhecimento de zona.

   ibmcloud ks cluster master refresh --cluster CLUSTER_NAME_OR_ID
   

9. Veja se a operação de atualização foi concluída revisando o Funcionamento do mestre nos detalhes do cluster.

   ibmcloud ks cluster get -c CLUSTER_NAME_OR_ID