Configure uma implementação do kube-dns personalizada

Padrão

Este documento explica como personalizar a configuração de DNS no seu cluster padrão do Google Kubernetes Engine (GKE) substituindo o kube-dns predefinido gerido pelo GKE pela sua própria implementação. Desta forma, tem mais controlo sobre o fornecedor de DNS do seu cluster. Por exemplo, pode:

• Ajuste os recursos de CPU e memória para os componentes de DNS.
• Usar uma versão específica da imagem kube-dns.
• Implemente um fornecedor DNS alternativo, como o CoreDNS, que cumpra a especificação de DNS do Kubernetes.

Este documento destina-se apenas a clusters padrão. A Google gere a configuração de DNS em clusters do Autopilot. Para uma compreensão mais detalhada dos fornecedores de DNS no GKE, consulte os artigos Acerca da descoberta de serviços e kube-dns.

Aviso: se executar uma implementação de DNS personalizada, é responsável pela respetiva manutenção contínua. Isto inclui garantir que as imagens de contentores do kube-dns e do escalador automático estão atualizadas com as versões e os patches de segurança mais recentes. Para encontrar as imagens recomendadas mais recentes, inspecione a implementação kube-dns predefinida no espaço de nomes kube-system de um cluster do GKE.

Este documento destina-se a utilizadores do GKE, incluindo programadores, administradores e arquitetos. Para saber mais sobre as funções comuns e exemplos de tarefas no Google Cloud, consulte o artigo Funções de utilizador e tarefas comuns do GKE Enterprise.

Este documento pressupõe que conhece o seguinte:

• Kubernetes Service.
• Serviços multicluster.
• Acerca da deteção de serviços.
• Deteção de serviços e DNS no GKE.
• Acerca do Cloud DNS.

Configure uma implementação do kube-dns personalizada

Esta secção explica como substituir o kube-dns gerido pelo GKE pela sua própria implementação.

Crie e implemente o manifesto personalizado

1. Guarde o seguinte manifesto Deployment como custom-kube-dns.yaml. Este manifesto usa kube-dns.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: DNS_DEPLOYMENT_NAME
     namespace: kube-system
     labels:
       k8s-app: kube-dns
     annotations:
       deployment.kubernetes.io/revision: "1"
   spec:
     selector:
       matchLabels:
         k8s-app: kube-dns
     strategy:
       rollingUpdate:
         maxSurge: 10%
         maxUnavailable: 0
       type: RollingUpdate
     template:
       metadata:
         creationTimestamp: null
         labels:
           k8s-app: kube-dns
       spec:
         containers:
         - name: kubedns
           image: registry.k8s.io/dns/k8s-dns-kube-dns:1.22.28
           resources:
             limits:
               memory: '170Mi'
             requests:
               cpu: 100m
               memory: '70Mi'
           livenessProbe:
             httpGet:
               path: /healthcheck/kubedns
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           readinessProbe:
             httpGet:
               path: /readiness
               port: 8081
               scheme: HTTP
             initialDelaySeconds: 3
             timeoutSeconds: 5
           args:
           - --domain=cluster.local.
           - --dns-port=10053
           - --config-dir=/kube-dns-config
           - --v=2
           env:
           - name: PROMETHEUS_PORT
             value: "10055"
           ports:
           - containerPort: 10053
             name: dns-local
             protocol: UDP
           - containerPort: 10053
             name: dns-tcp-local
             protocol: TCP
           - containerPort: 10055
             name: metrics
             protocol: TCP
           volumeMounts:
           - name: kube-dns-config
             mountPath: /kube-dns-config
           securityContext:
             allowPrivilegeEscalation: false
             readOnlyRootFilesystem: true
             runAsUser: 1001
             runAsGroup: 1001
         - name: dnsmasq
           image: registry.k8s.io/dns/k8s-dns-dnsmasq-nanny:1.22.28
           livenessProbe:
             httpGet:
               path: /healthcheck/dnsmasq
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           args:
           - -v=2
           - -logtostderr
           - -configDir=/etc/k8s/dns/dnsmasq-nanny
           - -restartDnsmasq=true
           - --
           - -k
           - --cache-size=1000
           - --no-negcache
           - --dns-forward-max=1500
           - --log-facility=-
           - --server=/cluster.local/127.0.0.1#10053
           - --server=/in-addr.arpa/127.0.0.1#10053
           - --server=/ip6.arpa/127.0.0.1#10053
           ports:
           - containerPort: 53
             name: dns
             protocol: UDP
           - containerPort: 53
             name: dns-tcp
             protocol: TCP
           resources:
             requests:
               cpu: 150m
               memory: 20Mi
           volumeMounts:
           - name: kube-dns-config
             mountPath: /etc/k8s/dns/dnsmasq-nanny
           securityContext:
             capabilities:
               drop:
               - all
               add:
               - NET_BIND_SERVICE
               - SETGID
         - name: sidecar
           image: registry.k8s.io/dns/k8s-dns-sidecar:1.22.28
           livenessProbe:
             httpGet:
               path: /metrics
               port: 10054
               scheme: HTTP
             initialDelaySeconds: 60
             timeoutSeconds: 5
             successThreshold: 1
             failureThreshold: 5
           args:
           - --v=2
           - --logtostderr
           - --probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.cluster.local,5,SRV
           - --probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.cluster.local,5,SRV
           ports:
           - containerPort: 10054
             name: metrics
             protocol: TCP
           resources:
             requests:
               memory: 20Mi
               cpu: 10m
           securityContext:
             allowPrivilegeEscalation: false
             readOnlyRootFilesystem: true
             runAsUser: 1001
             runAsGroup: 1001
         dnsPolicy: Default
         restartPolicy: Always
         schedulerName: default-scheduler
         securityContext: {}
         serviceAccount: kube-dns
         serviceAccountName: kube-dns
         terminationGracePeriodSeconds: 30
         tolerations:
         - key: CriticalAddonsOnly
           operator: Exists
         volumes:
         - configMap:
             defaultMode: 420
             name: kube-dns
             optional: true
           name: kube-dns-config
   

   Substitua DNS_DEPLOYMENT_NAME pelo nome da implementação de DNS personalizada.

2. Aplique o manifesto ao cluster:

   kubectl create -f custom-kube-dns.yaml
   

Reduza a escala do kube-dns gerido pelo GKE

Para evitar conflitos, desative as implementações kube-dns e kube-dns-autoscaler geridas pelo GKE reduzindo-as para zero réplicas:

kubectl scale deployment --replicas=0 kube-dns-autoscaler kube-dns --namespace=kube-system

Configure um escalador automático personalizado

A predefinição kube-dns-autoscaler apenas dimensiona a implementação kube-dns gerida pelo GKE. Se o seu fornecedor de DNS personalizado exigir o dimensionamento automático, tem de implementar um dimensionador automático separado e conceder-lhe autorizações para modificar a sua implementação de DNS personalizada.

1. Crie o seguinte manifesto e guarde-o como custom-dns-autoscaler.yaml.

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: custom-dns-autoscaler
     namespace: kube-system
   data:
     linear: |-
       {
         "coresPerReplica": 256,
         "nodesPerReplica": 16,
         "preventSinglePointFailure": true
       }
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: system:custom-dns-autoscaler
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: system:custom-dns-autoscaler
   subjects:
   - kind: ServiceAccount
     name: kube-dns-autoscaler
     namespace: kube-system
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: system:custom-dns-autoscaler
   rules:
   - apiGroups:
     - ""
     resources:
     - nodes
     verbs:
     - list
     - watch
   - apiGroups:
     - apps
     resourceNames:
     - DNS_DEPLOYMENT_NAME
     resources:
     - deployments/scale
     verbs:
     - get
     - update
   - apiGroups:
     - ""
     resources:
     - configmaps
     verbs:
     - get
     - create
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: custom-dns-autoscaler
     namespace: kube-system
     labels:
       k8s-app: custom-dns-autoscaler
   spec:
     selector:
       matchLabels:
         k8s-app: custom-dns-autoscaler
     template:
       metadata:
         labels:
           k8s-app: custom-dns-autoscaler
       spec:
         priorityClassName: system-cluster-critical
         securityContext:
           seccompProfile:
             type: RuntimeDefault
           supplementalGroups: [ 65534 ]
           fsGroup: 65534
         nodeSelector:
           kubernetes.io/os: linux
         containers:
         - name: autoscaler
           image: registry.k8s.io/autoscaling/cluster-proportional-autoscaler:1.8.9
           resources:
             requests:
               cpu: "20m"
               memory: "10Mi"
           command:
           - /cluster-proportional-autoscaler
           - --namespace=kube-system
           - --configmap=custom-dns-autoscaler
           - --target=Deployment/DNS_DEPLOYMENT_NAME
           - --default-params={"linear":{"coresPerReplica":256,"nodesPerReplica":16,"preventSinglePointFailure":true}}
           - --logtostderr=true
           - --v=2
         tolerations:
         - key: "CriticalAddonsOnly"
           operator: "Exists"
         serviceAccountName: kube-dns-autoscaler
   

   Substitua DNS_DEPLOYMENT_NAME no campo resourceNames e no campo command pelo nome da sua implementação de DNS personalizada.

2. Aplique o manifesto ao cluster:

   kubectl create -f custom-dns-autoscaler.yaml
   

Valide a implementação

Verifique se os seus pods de DNS personalizados estão em execução:

kubectl get pods -n kube-system -l k8s-app=kube-dns

Uma vez que dimensionou a implementação gerida pelo GKE kube-dns para zero réplicas, apenas os pods da sua implementação personalizada aparecem no resultado. Verifique se o estado é Running.

Restaure o kube-dns gerido pelo GKE

Se implementou uma configuração kube-dns personalizada e precisar de reverter para a configuração predefinida gerida pelo GKE, tem de eliminar os recursos personalizados e reativar a implementação kube-dns gerida.

Siga estes passos para restaurar o kube-dns gerido pelo GKE:

1. Elimine a implementação kube-dns personalizada e o respetivo redimensionador automático. Se guardou os manifestos como custom-kube-dns.yaml e custom-dns-autoscaler.yaml, execute os seguintes comandos para eliminar os recursos:

   kubectl delete -f custom-dns-autoscaler.yaml
   kubectl delete -f custom-kube-dns.yaml
   

   Se não guardou os manifestos, elimine manualmente a implementação, o ClusterRole e o ClusterRoleBinding que criou para a sua implementação personalizada.

2. Restaure o kube-dns-autoscaler gerido pelo GKE. Execute o seguinte comando para reduzir a implementação do kube-dns-autoscaler a uma réplica:

   kubectl scale deployment --replicas=1 kube-dns-autoscaler --namespace=kube-system
   

   Este comando reativa o kube-dns-autoscaler gerido, que, em seguida, dimensiona automaticamente a implementação do kube-dns gerido para o número adequado de réplicas para o tamanho do seu cluster.

3. Valide o restauro.

   Verifique os pods kube-dns e kube-dns-autoscaler para garantir que estão a ser executados corretamente:

   kubectl get pods -n kube-system -l k8s-app=kube-dns
   

   O resultado deve mostrar que os pods geridos pelo GKE estão no estado Running.kube-dns

O que se segue?

• Leia uma vista geral de como o GKE fornece DNS gerido.
• Leia o artigo DNS para serviços e pods para uma vista geral de como o DNS é usado em clusters do Kubernetes.