Optimize DNS resolution for an ACK cluster

Adjust the number of CoreDNS pods properly

Setting a proper ratio of CoreDNS pods to nodes in a Kubernetes cluster improves the performance of service discovery for the cluster. We recommend that you set the ratio to 1:8.

• If you do not want to expand your cluster on a large scale, you can run the following command to change the number of pods:

  kubectl scale --replicas={target} deployment/coredns -n kube-system

  Note Replace {target} with the required value.
• If you want to expand your cluster on a large scale, you can use the following YAML template to create a Deployment. Then, you can use cluster-proportional-autoscaler to dynamically scale the number of pods. We recommend that you do not use Horizontal Pod Autoscaler (HPA) to scale the number of pods when the QPS, CPU usage, or memory usage of pods reaches the threshold. HPA cannot meet the expected requirements.

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: dns-autoscaler
    namespace: kube-system
    labels:
      k8s-app: dns-autoscaler
  spec:
    selector:
      matchLabels:
         k8s-app: dns-autoscaler
    template:
      metadata:
        labels:
          k8s-app: dns-autoscaler
  
      spec:
        serviceAccountName: admin
        containers:
        - name: autoscaler
          image: registry.cn-hangzhou.aliyuncs.com/ringtail/cluster-proportional-autoscaler-amd64:v1.3.0
          resources:
              requests:
                  cpu: "200m"
                  memory: "150Mi"
          command:
            - /cluster-proportional-autoscaler
            - --namespace=kube-system
            - --configmap=dns-autoscaler
            - --target=Deployment/coredns
            - --default-params={"linear":{"coresPerReplica":64,"nodesPerReplica":8,"min":2,"max":100,"preventSinglePointFailure":true}}
            - --logtostderr=true
            - --v=2

  Note In the preceding linear scaling policy, the number of replicas for CoreDNS is calculated based on the following formula: Replicas = Max (Ceil (Cores × 1/coresPerReplica), Ceil (Nodes × 1/nodesPerReplica) ). The number of CoreDNS pod replicas is subject to the values of max and min in the linear scaling policy.

  The following code block shows the parameters of the linear scaling policy:

  {
        "coresPerReplica": 64,
        "nodesPerReplica": 8,
        "min": 2,
        "max": 100,
        "preventSinglePointFailure": true
  }

Use the autopath add-on

If the first resolution attempt fails, autopath splits the suffixes to make another attempt. The resolution is complete within two attempts (one for an IPv4 address and one for an IPv6 address).

Use autopath

Reference the following example and modify the kube-system/configmap coredns file by changing the content in the red boxes.

Use NodeLocal DNSCache in a Kubernetes cluster

NodeLocal DNSCache is deployed as a DaemonSet and runs a pod on each node of a Kubernetes cluster to process DNS queries. Queries of internal domain names are sent to CoreDNS and queries of external domain names are sent to external DNS servers. NodeLocal DNSCache also caches all DNS queries. NodeLocal DNSCache is an efficient DNS cache based on nodes, which can significantly improve the performance of domain name resolution for the cluster.

1. Log on to the ACK console.
2. In the left-side navigation pane of the ACK console, choose Marketplace > App Catalog.
3. In the upper-right corner of the App Catalog page, enter ack-node-local-dns in the Name search bar and click the search icon to search for NodeLocal DNSCache.
4. Click ack-node-local-dns and specify the parameters on the Parameters tab.

   Parameter	Description	Default
   upStreamIP	The IP address of a Service that uses the CoreDNS pod as the backend. NodeLocal DNSCache requests DNS resolution services from CoreDNS for domain names inside the cluster by sending DNS queries to this IP address. The value of this parameter must be an unused Service IP address. This parameter is required.	NULL
   kubeDnsIP	This parameter is required.The IP address of the virtual interface. NodeLocal DNSCache listens to DNS queries sent to the virtual interface IP address. This IP address determines how the CoreDNS pod is accessed. For more information, see README.	"169.254.20.10"
   clusterDomain	The base domain of the cluster.	"cluster.local"
   force_tcp	Specifies whether the upstream DNS server must use TCP for communication.	"false"

5. In the Deploy section, select a cluster to deploy the application and click Create.
   The namespace is automatically specified as kube-system, and the release name is automatically specified as ack-node-local-dns.
6. Run the following command to view the deployment status of node-local-dns:

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

   NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR                 AGE
   node-local-dns   1         1         1       1            1           beta.Kubernetes.io/os=linux   43d

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

   NAME                   READY   STATUS    RESTARTS   AGE
   node-local-dns-b8x4l   1/1     Running   1          43d
   node-local-dns-sf85d   1/1     Running   0          43d
   node-local-dns-wf547   1/1     Running   4          43d

   If the node-local-dns parameter appears in the result and the pods are in the Running state, node-local-dns is deployed.