Container Service for Kubernetes:Use AHPA to enable predictive scaling in Knative

Step 1: Install Application Intelligence Controller

Install Application Intelligence Controller from the Add-ons page of the Container Service for Kubernetes (ACK) console.

1. Log on to the ACK console.
2. In the left-side navigation pane of the ACK console, click Clusters.
3. On the Clusters page, find the cluster that you want to manage and click the name of the cluster or click Details in the Actions column. The details page of the cluster appears.
4. In the left-side navigation pane of the details page, choose Operations > Add-ons.
5. On the Add-ons page, click the Others tab. Find Application Intelligence Controller and click Install.
6. In the Install Application Intelligence Controller message, click OK.

Step 2: Configure Prometheus to collect metrics

Configure Prometheus to collect the response time (RT) and requests per second (RPS) metrics of your Knative Service.

1. Log on to the ARMS console.
2. In the left-side navigation pane, choose Prometheus Monitoring > Prometheus Instances.
3. In the top navigation bar, select the region in which your cluster resides and click the name of the Prometheus instance that is used to monitor your cluster in the Instance Name column. The details page of the Prometheus instance appears.
4. In the left-side navigation pane, click Service Discovery. Then, click the Configure tab.
5. On the Configure tab, click Custom Service Discovery. Then, click Add.
6. In the Add custom service discovery dialog box, configure metric collection rules.

   Example:

   job_name: queue-proxy
   scrape_interval: 3s
   scrape_timeout: 3s
   kubernetes_sd_configs:
   - role: pod
   relabel_configs:
   - source_labels:
     - __meta_kubernetes_pod_label_serving_knative_dev_revision
     - __meta_kubernetes_pod_container_port_name
     action: keep
     regex: .+;http-usermetric
   - source_labels:
     - __meta_kubernetes_namespace
     target_label: namespace
   - source_labels:
     - __meta_kubernetes_pod_name
     target_label: pod
   - source_labels:
     - __meta_kubernetes_service_name
     target_label: service

1. Log on to the ARMS console.
2. In the left-side navigation pane, choose Prometheus Monitoring > Prometheus Instances.
3. In the upper-left corner of the Prometheus Monitoring page, select the region in which your Prometheus instances are deployed. Then, click the name of a Prometheus instance whose Instance Type is Prometheus for Container Service. The details page of the Prometheus instance appears.
4. In the left-side navigation pane of the instance details page, click Settings and copy the public endpoint in the HTTP API Address section.
5. In the HTTP API Address section, click Generate Token to generate a token. The token is used to pass the authentication when you access the Prometheus instance.
6. Create an application-intelligence.yaml file with the following content. The file specifies the public endpoint of the Prometheus instance.

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: application-intelligence
     namespace: kube-system
   data:
     armsUrl: "https://cn-hangzhou.arms.aliyuncs.com:9443/api/v1/prometheus/da9d7dece901db4c9fc7f5b9c40****/158120454317****/cc6df477a982145d986e3f79c985a****/cn-hangzhou"
     token: "****"

   Descriptions of parameters:

   • armsUrl: Specify the public endpoint of the Prometheus instance that you copied in Step 4.
   • token: Specify the token that was generated in Step 5.
7. Run the following command to create a ConfigMap:

   kubectl apply -f application-intelligence.yaml

Step 3: Create a Knative Service

Create a Knative Service that has AHPA enabled.

1. Create an autoscale-go.yaml with the following content:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: autoscale-go
     namespace: default
   spec:
     template:
       metadata:
         labels:
           app: autoscale-go
         annotations:
           autoscaling.knative.dev/class: ahpa.autoscaling.knative.dev
           autoscaling.knative.dev/target: "500"
           autoscaling.knative.dev/metric: "rt"
           autoscaling.knative.dev/minScale: "1"
           autoscaling.knative.dev/maxScale: "30"
           autoscaling.alibabacloud.com/scaleStrategy: "observer"
       spec:
         containers:
           - image: registry.cn-hangzhou.aliyuncs.com/knative-sample/autoscale-go:0.1
                           

   Parameter	Description
   autoscaling.knative.dev/class: ahpa.autoscaling.knative.dev	Specifies that AHPA is enabled.
   autoscaling.knative.dev/metric: "rt"	The metric based on which AHPA scales your application. Only the RT metric is supported.
   autoscaling.knative.dev/target: "500	The scaling threshold for the metric. In this example, the threshold is set to 500 milliseconds.
   autoscaling.knative.dev/minScale: "1"	The minimum number of pods to which AHPA can scale your application. In this example, the value is set to 1.
   autoscaling.knative.dev/maxScale: "30"	The maximum number of pods to which AHPA can scale your application. In this example, the value is set to 30.
   autoscaling.alibabacloud.com/scaleStrategy: "observer"	The scaling mode of AHPA. Default value: observer. observer: AHPA observes but does not scale your application. You can use this mode to check whether AHPA works as expected. The default mode is observer because AHPA performs predictive scaling based on the historical data with the last seven days. auto: AHPA scales your application based on the collected metric and the specified threshold.

2. Run the following command to enable AHPA:

   kubectl apply -f autoscale-go.yaml

Verify the AHPA policy

You can compare the values of the RT metric of your Knative Service before and after AHPA predictive scaling is enabled, as shown in the following figure.