Autoscale 示例应用 - Go¶

Knative Serving Revision 的自动伸缩能力的演示。

先决条件¶

已安装 Knative Serving 的 Kubernetes 集群。
已安装 hey 负载生成器 (go install github.com/rakyll/hey@latest)。

克隆此仓库，并进入示例目录

git clone -b "{{ branch }}" https://github.com/knative/docs knative-docs
cd knative-docs

部署服务¶

部署示例 Knative Service

kubectl apply -f docs/versioned/serving/autoscaling/autoscale-go/service.yaml

获取服务的 URL（一旦 Ready）

$ kubectl get ksvc autoscale-go
NAME            URL                                                LATESTCREATED         LATESTREADY           READY   REASON
autoscale-go    http://autoscale-go.default.1.2.3.4.sslip.io    autoscale-go-96dtk    autoscale-go-96dtk    True

负载服务¶

向自动伸缩应用发出请求，以查看其消耗资源。

curl "http://autoscale-go.default.1.2.3.4.sslip.io?sleep=100&prime=10000&bloat=5"

Allocated 5 Mb of memory.
The largest prime less than 10000 is 9973.
Slept for 100.13 milliseconds.

发送 30 秒的流量，保持 50 个进行中的请求。

hey -z 30s -c 50 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?sleep=100&prime=10000&bloat=5" \
  && kubectl get pods

Summary:
  Total:        30.3379 secs
  Slowest:      0.7433 secs
  Fastest:      0.1672 secs
  Average:      0.2778 secs
  Requests/sec: 178.7861

  Total data:   542038 bytes
  Size/request: 99 bytes

Response time histogram:
  0.167 [1]     |
  0.225 [1462]  |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
  0.282 [1303]  |■■■■■■■■■■■■■■■■■■■■■■■■■■■■
  0.340 [1894]  |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
  0.398 [471]   |■■■■■■■■■■
  0.455 [159]   |■■■
  0.513 [68]    |■
  0.570 [18]    |
  0.628 [14]    |
  0.686 [21]    |
  0.743 [13]    |

Latency distribution:
  10% in 0.1805 secs
  25% in 0.2197 secs
  50% in 0.2801 secs
  75% in 0.3129 secs
  90% in 0.3596 secs
  95% in 0.4020 secs
  99% in 0.5457 secs

Details (average, fastest, slowest):
  DNS+dialup:   0.0007 secs, 0.1672 secs, 0.7433 secs
  DNS-lookup:   0.0000 secs, 0.0000 secs, 0.0000 secs
  req write:    0.0001 secs, 0.0000 secs, 0.0045 secs
  resp wait:    0.2766 secs, 0.1669 secs, 0.6633 secs
  resp read:    0.0002 secs, 0.0000 secs, 0.0065 secs

Status code distribution:
  [200] 5424 responses

NAME                                             READY   STATUS    RESTARTS   AGE
autoscale-go-00001-deployment-78cdc67bf4-2w4sk   3/3     Running   0          26s
autoscale-go-00001-deployment-78cdc67bf4-dd2zb   3/3     Running   0          24s
autoscale-go-00001-deployment-78cdc67bf4-pg55p   3/3     Running   0          18s
autoscale-go-00001-deployment-78cdc67bf4-q8bf9   3/3     Running   0          1m
autoscale-go-00001-deployment-78cdc67bf4-thjbq   3/3     Running   0          26s

分析¶

算法¶

Knative Serving 的自动伸缩基于每个 Pod 的平均进行中请求数（并发度）。系统默认的目标并发度为 100（搜索 container-concurrency-target-default），但我们为服务使用了 10。我们用 50 个并发请求负载服务，因此自动伸缩器创建了 5 个 Pod（50 个并发请求 / 目标 10 = 5 个 Pod）

恐慌模式¶

自动伸缩器根据 60 秒的时间窗口计算平均并发度，因此系统需要一分钟才能稳定在所需的并发度水平。然而，自动伸缩器也会计算 6 秒的 panic 窗口，如果该窗口达到目标并发度的 2 倍，系统将进入恐慌模式。在恐慌模式下，自动伸缩器在更短、更敏感的恐慌窗口上运行。一旦恐慌条件在 60 秒内不再满足，自动伸缩器将返回初始的 60 秒 稳定 窗口。

                                                       |
                                  Panic Target--->  +--| 20
                                                    |  |
                                                    | <------Panic Window
                                                    |  |
       Stable Target--->  +-------------------------|--| 10   CONCURRENCY
                          |                         |  |
                          |                      <-----------Stable Window
                          |                         |  |
--------------------------+-------------------------+--+ 0
120                       60                           0
                     TIME

自定义¶

自动伸缩器支持通过注解进行自定义。Knative 内置了两种自动伸缩器类：

kpa.autoscaling.knative.dev，即前面描述的基于并发度的自动伸缩器（默认），以及
hpa.autoscaling.knative.dev，它委托给 Kubernetes HPA，后者根据 CPU 使用率进行自动伸缩。

按 CPU 伸缩的 Service 示例

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: autoscale-go
  namespace: default
spec:
  template:
    metadata:
      annotations:
        # Standard Kubernetes CPU-based autoscaling.
        autoscaling.knative.dev/class: hpa.autoscaling.knative.dev
        autoscaling.knative.dev/metric: cpu
    spec:
      containers:
        - image: ghcr.io/knative/autoscale-go:latest

此外，可以在注解中指定自动伸缩器的目标和伸缩边界。具有自定义目标和伸缩边界的 Service 示例

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: autoscale-go
  namespace: default
spec:
  template:
    metadata:
      annotations:
        # Knative concurrency-based autoscaling (default).
        autoscaling.knative.dev/class: kpa.autoscaling.knative.dev
        autoscaling.knative.dev/metric: concurrency
        # Target 10 requests in-flight per pod.
        autoscaling.knative.dev/target: "10"
        # Disable scale to zero with a min scale of 1.
        autoscaling.knative.dev/min-scale: "1"
        # Limit scaling to 100 pods.
        autoscaling.knative.dev/max-scale: "100"
    spec:
      containers:
        - image: ghcr.io/knative/autoscale-go:latest

注意

对于 hpa.autoscaling.knative.dev 类的 Service，autoscaling.knative.dev/target 指定 CPU 百分比目标（默认 "80"）。

演示¶

查看 Knative 自动伸缩器自定义的 Kubecon 演示（32 分钟）。

其他实验¶

发送 60 秒的流量，保持 100 个并发请求。

hey -z 60s -c 100 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?sleep=100&prime=10000&bloat=5"

发送 60 秒的流量，保持 100 qps 和短请求（10 毫秒）。

hey -z 60s -q 100 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?sleep=10"

发送 60 秒的流量，保持 100 qps 和长请求（1 秒）。

hey -z 60s -q 100 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?sleep=1000"

发送 60 秒的流量，保持高 CPU 使用率（~1 cpu/秒/请求，总共 100 个 cpu）。
```
hey -z 60s -q 100 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?prime=40000000"
```

发送 60 秒的流量，保持高内存使用率（1 gb/请求，总共 5 gb）。

hey -z 60s -c 5 \
  "http://autoscale-go.default.1.2.3.4.sslip.io?bloat=1000"

清理¶

kubectl delete -f docs/versioned/serving/autoscaling/autoscale-go/service.yaml

深入阅读¶

自动伸缩开发者文档