Autoscale the DNS Service in a Cluster

This page shows how to enable and configure autoscaling of the DNS service in your Kubernetes cluster.

Before you begin

  • You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a cluster, you can create one by using minikube or you can use one of these Kubernetes playgrounds:

    To check the version, enter kubectl version.

  • This guide assumes your nodes use the AMD64 or Intel 64 CPU architecture.

  • Make sure Kubernetes DNS is enabled.

Determine whether DNS horizontal autoscaling is already enabled

List the Deployments in your cluster in the kube-system namespace:

  1. kubectl get deployment --namespace=kube-system

The output is similar to this:

  1. NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
  2. ...
  3. dns-autoscaler            1/1     1            1           ...
  4. ...

If you see “dns-autoscaler” in the output, DNS horizontal autoscaling is already enabled, and you can skip to Tuning autoscaling parameters.

Get the name of your DNS Deployment

List the DNS deployments in your cluster in the kube-system namespace:

  1. kubectl get deployment -l k8s-app=kube-dns --namespace=kube-system

The output is similar to this:

  1. NAME      READY   UP-TO-DATE   AVAILABLE   AGE
  2. ...
  3. coredns   2/2     2            2           ...
  4. ...

If you don’t see a Deployment for DNS services, you can also look for it by name:

  1. kubectl get deployment --namespace=kube-system

and look for a deployment named coredns or kube-dns.

Your scale target is

  1. Deployment/<your-deployment-name>

where <your-deployment-name> is the name of your DNS Deployment. For example, if the name of your Deployment for DNS is coredns, your scale target is Deployment/coredns.

Note: CoreDNS is the default DNS service for Kubernetes. CoreDNS sets the label k8s-app=kube-dns so that it can work in clusters that originally used kube-dns.

Enable DNS horizontal autoscaling

In this section, you create a new Deployment. The Pods in the Deployment run a container based on the cluster-proportional-autoscaler-amd64 image.

Create a file named dns-horizontal-autoscaler.yaml with this content:

admin/dns/dns-horizontal-autoscaler.yaml

  1. kind: ServiceAccount
  2. apiVersion: v1
  3. metadata:
  4.   name: kube-dns-autoscaler
  5.   namespace: kube-system
  6. ---
  7. kind: ClusterRole
  8. apiVersion: rbac.authorization.k8s.io/v1
  9. metadata:
  10.   name: system:kube-dns-autoscaler
  11. rules:
  12.   - apiGroups: [""]
  13.     resources: ["nodes"]
  14.     verbs: ["list", "watch"]
  15.   - apiGroups: [""]
  16.     resources: ["replicationcontrollers/scale"]
  17.     verbs: ["get", "update"]
  18.   - apiGroups: ["apps"]
  19.     resources: ["deployments/scale", "replicasets/scale"]
  20.     verbs: ["get", "update"]
  21. # Remove the configmaps rule once below issue is fixed:
  22. # kubernetes-incubator/cluster-proportional-autoscaler#16
  23.   - apiGroups: [""]
  24.     resources: ["configmaps"]
  25.     verbs: ["get", "create"]
  26. ---
  27. kind: ClusterRoleBinding
  28. apiVersion: rbac.authorization.k8s.io/v1
  29. metadata:
  30.   name: system:kube-dns-autoscaler
  31. subjects:
  32.   - kind: ServiceAccount
  33.     name: kube-dns-autoscaler
  34.     namespace: kube-system
  35. roleRef:
  36.   kind: ClusterRole
  37.   name: system:kube-dns-autoscaler
  38.   apiGroup: rbac.authorization.k8s.io
  40. ---
  41. apiVersion: apps/v1
  42. kind: Deployment
  43. metadata:
  44.   name: kube-dns-autoscaler
  45.   namespace: kube-system
  46.   labels:
  47.     k8s-app: kube-dns-autoscaler
  48.     kubernetes.io/cluster-service: "true"
  49. spec:
  50.   selector:
  51.     matchLabels:
  52.       k8s-app: kube-dns-autoscaler
  53.   template:
  54.     metadata:
  55.       labels:
  56.         k8s-app: kube-dns-autoscaler
  57.     spec:
  58.       priorityClassName: system-cluster-critical
  59.       securityContext:
  60.         seccompProfile:
  61.           type: RuntimeDefault
  62.         supplementalGroups: [ 65534 ]
  63.         fsGroup: 65534
  64.       nodeSelector:
  65.         kubernetes.io/os: linux
  66.       containers:
  67.       - name: autoscaler
  68.         image: k8s.gcr.io/cpa/cluster-proportional-autoscaler:1.8.4
  69.         resources:
  70.             requests:
  71.                 cpu: "20m"
  72.                 memory: "10Mi"
  73.         command:
  74.           - /cluster-proportional-autoscaler
  75.           - --namespace=kube-system
  76.           - --configmap=kube-dns-autoscaler
  77.           # Should keep target in sync with cluster/addons/dns/kube-dns.yaml.base
  78.           - --target=<SCALE_TARGET>
  79.           # When cluster is using large nodes(with more cores), "coresPerReplica" should dominate.
  80.           # If using small nodes, "nodesPerReplica" should dominate.
  81.           - --default-params={"linear":{"coresPerReplica":256,"nodesPerReplica":16,"preventSinglePointFailure":true,"includeUnschedulableNodes":true}}
  82.           - --logtostderr=true
  83.           - --v=2
  84.       tolerations:
  85.       - key: "CriticalAddonsOnly"
  86.         operator: "Exists"
  87.       serviceAccountName: kube-dns-autoscaler

In the file, replace <SCALE_TARGET> with your scale target.

Go to the directory that contains your configuration file, and enter this command to create the Deployment:

  1. kubectl apply -f dns-horizontal-autoscaler.yaml

The output of a successful command is:

  1. deployment.apps/dns-autoscaler created

DNS horizontal autoscaling is now enabled.

Tune DNS autoscaling parameters

Verify that the dns-autoscaler ConfigMap exists:

  1. kubectl get configmap --namespace=kube-system

The output is similar to this:

  1. NAME                  DATA      AGE
  2. ...
  3. dns-autoscaler        1         ...
  4. ...

Modify the data in the ConfigMap:

  1. kubectl edit configmap dns-autoscaler --namespace=kube-system

Look for this line:

  1. linear: '{"coresPerReplica":256,"min":1,"nodesPerReplica":16}'

Modify the fields according to your needs. The “min” field indicates the minimal number of DNS backends. The actual number of backends is calculated using this equation:

  1. replicas = max( ceil( cores × 1/coresPerReplica ) , ceil( nodes × 1/nodesPerReplica ) )

Note that the values of both coresPerReplica and nodesPerReplica are floats.

The idea is that when a cluster is using nodes that have many cores, coresPerReplica dominates. When a cluster is using nodes that have fewer cores, nodesPerReplica dominates.

There are other supported scaling patterns. For details, see cluster-proportional-autoscaler.

Disable DNS horizontal autoscaling

There are a few options for tuning DNS horizontal autoscaling. Which option to use depends on different conditions.

Option 1: Scale down the dns-autoscaler deployment to 0 replicas

This option works for all situations. Enter this command:

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

The output is:

  1. deployment.apps/dns-autoscaler scaled

Verify that the replica count is zero:

  1. kubectl get rs --namespace=kube-system

The output displays 0 in the DESIRED and CURRENT columns:

  1. NAME                                 DESIRED   CURRENT   READY   AGE
  2. ...
  3. dns-autoscaler-6b59789fc8            0         0         0       ...
  4. ...

Option 2: Delete the dns-autoscaler deployment

This option works if dns-autoscaler is under your own control, which means no one will re-create it:

  1. kubectl delete deployment dns-autoscaler --namespace=kube-system

The output is:

  1. deployment.apps "dns-autoscaler" deleted

Option 3: Delete the dns-autoscaler manifest file from the master node

This option works if dns-autoscaler is under control of the (deprecated) Addon Manager, and you have write access to the master node.

Sign in to the master node and delete the corresponding manifest file. The common path for this dns-autoscaler is:

  1. /etc/kubernetes/addons/dns-horizontal-autoscaler/dns-horizontal-autoscaler.yaml

After the manifest file is deleted, the Addon Manager will delete the dns-autoscaler Deployment.

Understanding how DNS horizontal autoscaling works

  • The cluster-proportional-autoscaler application is deployed separately from the DNS service.

  • An autoscaler Pod runs a client that polls the Kubernetes API server for the number of nodes and cores in the cluster.

  • A desired replica count is calculated and applied to the DNS backends based on the current schedulable nodes and cores and the given scaling parameters.

  • The scaling parameters and data points are provided via a ConfigMap to the autoscaler, and it refreshes its parameters table every poll interval to be up to date with the latest desired scaling parameters.

  • Changes to the scaling parameters are allowed without rebuilding or restarting the autoscaler Pod.

  • The autoscaler provides a controller interface to support two control patterns: linear and ladder.

What’s next