自动伸缩示例应用程序 - Go¶

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

先决条件¶

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

克隆此仓库，并移动到示例目录

git clone -b "release-1.16" https://github.com/knative/docs knative-docs
cd knative-docs

部署服务¶

部署示例 Knative 服务

kubectl apply -f docs/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 秒 stable 窗口。

                                                       |
                                  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 伸缩服务的示例

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

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

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 类服务，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/serving/autoscaling/autoscale-go/service.yaml

进一步阅读¶

自动伸缩开发人员文档