简介：   如何做性能测试？要么是通过编码的方式完成，写一堆脚本，用完即弃；要么是基于平台，在平台定义的流程中进行。对于后者，通常由于目标场景的复杂性，如部署特定的 workload、观测特定的性能项、网络访问问题等，往往导致性能测试平台要以高成本才能满足不断变化的开发场景的需求。在云原生的背景下，是否可以更好解决这种问题？

引子

性能测试在日常的开发工作中是常规需求，用来摸底服务的性能。

那么如何做性能测试？要么是通过编码的方式完成，写一堆脚本，用完即弃；要么是基于平台，在平台定义的流程中进行。对于后者，通常由于目标场景的复杂性，如部署特定的 workload、观测特定的性能项、网络访问问题等，往往导致性能测试平台要以高成本才能满足不断变化的开发场景的需求。

在云原生的背景下，是否可以更好解决这种问题？

先看两个 yaml 文件：

• performance-test.yaml 描述了在 K8s 中的操作流程：

  1. 创建测试用的 Namespace
  2. 启动针对 Deployment 创建效率和创建成功率的监控
  3. 下述动作重复 N 次：① 使用 workload 模板创建 Deployment；② 等待 Deployment 变为 Ready
  4. 删除测试用的 Namespace
• basic-1-pod-deployment.yaml 描述使用的 workload 模板

performance-test.yaml ：

apiVersion: aliyun.com/v1alpha1
kind: Beidou
metadata:
  name: performance
  namespace: beidou
spec:
  steps:
  - name: "Create Namespace If Not Exits"
    operations:
    - name: "create namespace"
      type: Task
      op: CreateNamespace
      args:
      - name: NS
        value: beidou
  - name: "Monitor Deployment Creation Efficiency"
    operations:
    - name: "Begin To Monitor Deployment Creation Efficiency"
      type: Task
      op: DeploymentCreationEfficiency
      args:
      - name: NS
        value: beidou
    - name: "Repeat 1 Times"
      type: Task
      op: RepeatNTimes
      args:
      - name: TIMES
        value: "1"
      - name: ACTION
        reference:
          id: deployment-operation
  - name: "Delete namespace"
    operations:
    - name: "delete namespace"
      type: Task
      op: DeleteNamespace
      args:
      - name: NS
        value: beidou
      - name: FORCE
        value: "false"
  references:
  - id: deployment-operation
    steps:
    - name: "Prepare Deployment"
      operations:
      - name: "Prepare Deployment"
        type: Task
        op: PrepareBatchDeployments
        args:
        - name: NS
          value: beidou
        - name: NODE_TYPE
          value: ebm
        - name: BATCH_NUM
          value: "1"
        - name: TEMPLATE
          value: "./templates/basic-1-pod-deployment.yaml"
        - name: DEPLOYMENT_REPLICAS
          value: "1"
        - name: DEPLOYMENT_PREFIX
          value: "ebm"
      - name: "Wait For Deployments To Be Ready"
        type: Task
        op: WaitForBatchDeploymentsReady
        args:
        - name: NS
          value: beidou
        - name: TIMEOUT
          value: "3m"
        - name: CHECK_INTERVAL
          value: "2s"

basic-1-pod-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: basic-1-pod
spec:
  selector:
    matchLabels:
      app: basic-1-pod
  template:
    metadata:
      labels:
        app: basic-1-pod
    spec:
      containers:
      - name: nginx
        image: registry-vpc.cn-hangzhou.aliyuncs.com/xxx/nginx:1.17.9
        imagePullPolicy: Always
        resources:
          limits:
            cpu: 2
            memory: 4Gi

然后通过一个命令行工具执行 performance-test.yaml：

$ beidou server -c ~/.kube/config services/performance-test.yaml

执行效果如下 (每个 Deployment 创建耗时，所有 Deployment 创建耗时的 TP95 值，每个 Deployment 是否创建成功)：

这些 metrics 是按照 Prometheus 标准输出，可以被 Prometheus server 收集走，再结合 Grafana 可以可视化展示性能测试数据。

通过在 yaml 中表达想法，编排对 K8s 资源的操作、监控，再也不用为性能测试的实现头疼了 :D

为什么要在 yaml 中编程？

性能测试、回归测试等对于服务质量保障有很大帮助，需要做，但常规的实现方法在初期需要投入较多的时间和精力，新增变更后维护成本比较高。

通常这个过程是以代码的方式实现原子操作，如创建 Deployment、检测 Pod 配置等，然后再组合原子操作来满足需求，如 创建 Deployment -> 等待 Deployment ready -> 检测 Pod 配置等。

有没有办法在实现的过程中既可以尽量低成本实现，又可以复用已有的经验？

可以将原子操作封装为原语，如 CreateDeployment、CheckPod，再通过 yaml 的结构表达流程，那么就可以通过 yaml 而非代码的方式描述想法，又可以复用他人已经写好的 yaml 文件来解决某类场景的需求。

即在 yaml 中编程，减少重复性代码工作，通过 声明式 的方式描述逻辑，并以 yaml 文件来满足场景级别的复用。

业界有很多种类型的 声明式操作 服务，如运维领域中的 Ansible、SaltStack，Kubernetes 中的Argo Workflow、clusterloader2。它们的思想整体比较类似，将高频使用的操作封装为原语，使用者通过原语来表述操作逻辑。

通过声明式的方法，将面向 K8s 的操作抽象成 yaml 中的关键词，在 yaml 中提供串行、并行等控制逻辑，那么就可以通过 yaml 文件完整描述想要进行的工作。

这种思想和 Argo Workflow 比较像，但粒度比 Argo 更细，关注在操作函数上：

下面简单描述该服务的设计和实现。

设计和实现

1. 服务形态

• 使用者在 yaml 中，通过 声明式 的方式描述操作逻辑；
• 以 all-in-one 的二进制工具或 Operator 的方式交付；
• 服务内置常见原语的实现，以关键字的方式在 yaml 中提供；
• 支持配置原生 K8s 资源。

2. 设计

该方案的核心在于配置管理的设计，将操作流程配置化，自上而下有如下概念：

• Service：Modules 或 Tasks 的编排；
• Module：一种任务场景，是操作单元的集合（其中包含 templates/ 目录，表征模板文件的集合，可用来配置 K8s 原生资源）；
   
• Task：操作单元，使用 plugin 及参数执行操作；
   
• Plugin：操作指令，类似开发语言中的函数。

抽象目标场景中的通用操作，这些通用操作即为可在 yaml 中使用的原语，对应上述 Plugin：

• K8s 相关

  • CreateNamespace
  • DeleteNamespace
  • PrepareSecret
  • PrepareConfigMap
  • PrepareBatchDeployments
  • WaitForBatchDeploymentsReady
  • etc.

• 观测性相关

  • DeploymentCreationEfficiency
  • PodCreationEfficiency
  • etc.

• 检测项相关

  • CheckPodAnnotations
  • CheckPodObjectInfo
  • CheckPodInnerStates
  • etc.

• 控制语句相关

  • RepeatNTimes
  • etc.

上述 4 个概念的关系如下：

示例可参见文章开头的 yaml 文件，对应形式二。

3. 核心实现

CRD 设计：

package v1alpha1

import (
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// BeidouType is the type related to Beidou execution.
type BeidouType string

const (
    // BeidouTask represents the Task execution type.
    BeidouTask BeidouType = "Task"
)

// +genclient
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// Beidou represents a crd used to describe serices.
type Beidou struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

    Spec   BeidouSpec   `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
    Status BeidouStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}

// BeidouSpec is the spec of a Beidou.
type BeidouSpec struct {
    Steps      []BeidouStep      `json:"steps" protobuf:"bytes,1,opt,name=steps"`
    References []BeidouReference `json:"references" protobuf:"bytes,2,opt,name=references"`
}

// BeidouStep is the spec of step.
type BeidouStep struct {
    Name       string            `json:"name" protobuf:"bytes,1,opt,name=name"`
    Operations []BeidouOperation `json:"operations" protobuf:"bytes,2,opt,name=operations"`
}

// BeidouOperation is the spec of operation.
type BeidouOperation struct {
    Name string      `json:"name" protobuf:"bytes,1,opt,name=name"`
    Type BeidouType  `json:"type" protobuf:"bytes,2,opt,name=type"`
    Op   string      `json:"op" protobuf:"bytes,3,opt,name=op"`
    Args []BeidouArg `json:"args" protobuf:"bytes,4,opt,name=args"`
}

// BeidouArg is the spec of arg.
type BeidouArg struct {
    Name        string                   `json:"name" protobuf:"bytes,1,opt,name=name"`
    Value       string                   `json:"value,omitempty" protobuf:"bytes,2,opt,name=value"`
    Reference   BeidouOperationReference `json:"reference,omitempty" protobuf:"bytes,3,opt,name=reference"`
    Tolerations []corev1.Toleration      `json:"tolerations,omitempty" protobuf:"bytes,4,opt,name=tolerations"`
    Checking    []string                 `json:"checking,omitempty" protobuf:"bytes,5,opt,name=checking"`
}

// BeidouOperationReference is the spec of operation reference.
type BeidouOperationReference struct {
    ID string `json:"id" protobuf:"bytes,1,opt,name=id"`
}

// BeidouReference is the spec of reference.
type BeidouReference struct {
    ID    string       `json:"id" protobuf:"bytes,1,opt,name=id"`
    Steps []BeidouStep `json:"steps" protobuf:"bytes,2,opt,name=steps"`
}

// BeidouStatus represents the current state of a Beidou.
type BeidouStatus struct {
    Message string `json:"message" protobuf:"bytes,1,opt,name=message"`
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// BeidouList is a collection of Beidou.
type BeidouList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"`

    Items []Beidou `json:"items" protobuf:"bytes,2,opt,name=items"`
}

核心流程：

// ExecSteps executes steps.
func ExecSteps(ctx context.Context, steps []v1alpha1.BeidouStep, references []v1alpha1.BeidouReference) error {
    logger, _ := ctx.Value(CtxLogger).(*log.Entry)

    var hasMonitored bool
    for i, step := range steps {
        for j, op := range step.Operations {
            switch op.Op {
            case "DeploymentCreationEfficiency":
                if !hasMonitored {
                    defer func() {
                        err := monitor.Output()
                        if err != nil {
                            logger.Errorf("Failed to output: %s", err)
                        }
                    }()
                }
                hasMonitored = true
            }

            err := ExecOperation(ctx, op, references)
            if err != nil {
                return fmt.Errorf("failed to run operation %s: %s", op.Name, err)
            }
        }
    }

    return nil
}

// ExecOperation executes operation.
func ExecOperation(ctx context.Context, op v1alpha1.BeidouOperation, references []v1alpha1.BeidouReference) error {
    switch op.Type {
    case v1alpha1.BeidouTask:
        if !tasks.IsRegistered(op.Op) {
            return ErrNotRegistered
        }

        if !tasks.DoesSupportReference(op.Op) {
            return ExecTask(ctx, op.Op, op.Args)
        }

        return ExecTaskWithRefer(ctx, op.Op, op.Args, references)
    }

    return nil
}

// ExecTask executes a task.
func ExecTask(ctx context.Context, opname string, args []v1alpha1.BeidouArg) error {
    switch opname {
    case tasks.CreateNamespace:
        var ns string
        for _, arg := range args {
            switch arg.Name {
            case "NS":
                ns = arg.Value
            }
        }

        return op.CreateNamespace(ctx, ns)
    // ...
    }
    // ...
}

// ExecTaskWithRefer executes a task with reference.
func ExecTaskWithRefer(ctx context.Context, opname string, args []v1alpha1.BeidouArg, references []v1alpha1.BeidouReference) error {
    switch opname {
    case tasks.RepeatNTimes:
        var times int
        var steps []v1alpha1.BeidouStep
        var err error
        for _, arg := range args {
            switch arg.Name {
            case "TIMES":
                times, err = strconv.Atoi(arg.Value)
                if err != nil {
                    return ErrParseArgs
                }
            case "ACTION":
                for _, refer := range references {
                    if refer.ID == arg.Reference.ID {
                        steps = refer.Steps
                        break
                    }
                }
            }
        }

        return RepeatNTimes(ctx, times, steps)
    }

    return ErrNotImplemented
}

操作原语的实现示例：

// PodAnnotations is an operation used to check whether annotations of Pod are expected.
func PodAnnotations(ctx context.Context, data PodAnnotationsData) error {
    kclient, ok := ctx.Value(tasks.KubernetesClient).(kubernetes.Interface)
    if !ok {
        return tasks.ErrNoKubernetesClient
    }

    pods, err := kclient.CoreV1().Pods(data.Namespace).List(metav1.ListOptions{})
    if err != nil {
        return fmt.Errorf("failed to list pods in ns %s: %s", data.Namespace, err)
    }

    for _, pod := range pods.Items {
        if pod.Annotations == nil {
            return fmt.Errorf("pod %s in ns %s has no annotations", pod.Name, data.Namespace)
        }

        for _, annotation := range data.Exists {
            if _, exists := pod.Annotations[annotation]; !exists {
                return fmt.Errorf("annotation %s does not exist in pod %s in ns %s", annotation, pod.Name, data.Namespace)
            }
        }

        for k, v := range data.Equal {
            if pod.Annotations[k] != v {
                return fmt.Errorf("value of annotation %s is not %s in pod %s in ns %s", k, v, pod.Name, data.Namespace)
            }
        }
    }

    return nil
}

后续

目前阿里云容器服务团队内部已经实现了初版，已用于部分云产品的内部性能测试以及常规的回归测试，很大程度上提升了我们的工作效率。

在 yaml 中编程，是对云原生场景下声明式操作的体现，也是对声明式服务的一种实践。对于常规工作场景中重复编码或重复操作，可考虑类似的方式进行满足。

欢迎大家对这样的服务形态和项目进行讨论，探索这种模式的价值。

# 对象类型：对象的一组键值对，使用冒号结构表示
name: Tom
age: 18

# yaml 也允许另一种写法，将所有键值对写成一个行内对象
hash: {name: Tom, age: 18}

# 数组类型：一组连词线开头的行，构成一个数组
People
- Tom
- Jack

# 数组也可以采用行内表示法
People: [Tom, Jack]

#数值直接以字面量的形式表示
number: 12.30

#布尔值用true和false表示
isset: true


#nu71用~表示
parent: ~

#时间采用Iso8601格式
iso8601:2001-12-14t21:59:43.10-05:00

#日期采用复合iso8601格式的年、月、日表示
date: 1976-07-31

#YAML 允许使用两个感叹号，强制转换数据类型
e: ! !str 123
f: ! !str true

#字符串默认不使用引号表示
str:这是一行字符串

#如果字符串之中包含空格或特殊字符，需要放在引号之中
str: '内容:字符串'

#单引号和双引号都可以使用，双引号不会对特殊字符转义
s1:'内容\n字符串'
s2:"内容\n字符串"

#单引号之中如果还有单引号，必须连续使用两个单引号转义
str: 'labor' 's day'

#字符串可以写成多行，从第二行开始，必须有一个单空格缩进。换行符会被转为空格
str:这是一段
多行
字符串

#多行字符串可以使用|保留换行符，也可以使用>折叠换行
this: |
Foo
Bar
thatFooBar

apiVersion: apps/v1  #api的版本
kind: Deployment  #deployment是用来管理pod的
Metadata:  #元数据对象，固定值写Metadata
 name: Nginx-deployment   #元数据对象的名字，由我们编写，比如命名pod的名字
 namespace: default    #元数据对象的命令空间，由我们自身定义
spec:   #详细定义对象，固定式写spec
 replicas: 3 #有哪些副本
 selector: #用那个选择器
  matchLabels: 
   app: nainx #应用的名字

template:  #pod模板
 Metadata:
  labels:  #标签
   app: Nginx  #应用名字
  spec:
   containers:
   - name: Nginx
   image: Nginx:latest
   ports:
   - containerPort: 80

apiVersion: v1
kind: namespace
Metadata:  #元数据对象，固定值写Metadata
 name: test

apiVersion: v1
kind: pod
Metadata: 
 name: pod1
spec: 
 containers: 
 - name: Nginx-containers
   image: Nginx: latest

# 尝试运行,并不会真正的创建镜像
[root@localhost ~]$ kubectl create deployment web --image=Nginx -o yaml --dry-run
#-o yaml: 把操作用yaml格式生成出来
#--dry-run: 尝试运行，并不真正执行，空跑的意思

[root@localhost ~]$ kubectl create deployment web --image=Nginx -o yaml --dry-run > demo.yaml

[root@localhost ~]$ kubectl get deploy

[root@localhost ~]$ kubectl get deploy Nginx -o=yaml > Nginx.yaml
#会生成一个 Nginx.yaml 的配置文件
#高版本没有--export，如果报错就去掉--export

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    os: centos
spec:
  containers:
  - name: hello
    image: centos:6
    env:
    - name: Test
      value: "123456"
    command: ["bash","-c","while true;do date;sleep 1;done"]

# api版本
apiVersion: v1
# 指定创建资源对象
kind: Pod
# 源数据、可以写name，命名空间，对象标签
metadata:
# 服务名称
  name: pod-test
# 标签
  labels:
# 标签名
    os: centos
# 容器资源信息
spec:
# 容器管理
  containers:
# 容器名称
  - name: hello
# 容器镜像
    image: centos:6
# 添加环境变量
    env:
# 创建key
    - name: Test
# 创建value
      value: "123456"
# 启动容器后执行命令
    command: ["bash","-c","while true;do date;sleep 1;done"]

kubectl create -f pod.yaml

基本管理：
# 创建pod资源
kubectl create -f pod.yaml
# 查看pods
kubectl get pods pod-test
# 查看pod描述
kubectl describe pod pod-test
# 替换资源
kubectl replace -f pod.yaml -force
# 删除资源
kubectl delete pod pod-test

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3

kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.9
        ports:
        - containerPort: 80

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.9
        ports:
        - containerPort: 80

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.9
        ports:
        - containerPort: 80

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.9
        ports:
        - containerPort: 80

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    os: centos
spec:
  containers:
  - name: hello
    image: centos:6
    env:
    # 变量key
    - name: Test
    # 变量value
      value: "123456"

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    os: centos
spec:
  containers:
  - name: hello
    image: centos:6
    command: ["bash","-c","while true;do date;sleep 1;done"]

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    os: centos
spec:
  containers:
  - name: hello
    image: centos:6
  restartPolicy: OnFailure

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.10
    ports:
    - containerPort: 80
    livenessProbe:
       # 健康检查模式
       httpGet:
         # 指定检查目录
         path: /index.html
         # 访问端口
         port: 80

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    test: centos
spec:
  containers:
  - name: hello-read
    image: centos:6
    # 容器内管理数据卷
    volumeMounts:
      # 数据卷名称
      - name: data
        # 容器数据卷路径
        mountPath: /data
  # 数据卷
  volumes:
  # 数据卷名称
  - name: data
    # 数据宿主机卷路径
    hostPath:
      # 指定宿主机数据卷路径
      path: /data

apiVersion: v1
kind: Pod
metadata:
  name: pod-test
  labels:
    test: centos
spec:
  containers:
  - name: hello-read
    image: centos:6
    # 容器内管理数据卷
    volumeMounts:
      # 数据卷名称
      - name: data
        # 容器数据卷路径
        mountPath: /data
  # 数据卷
  volumes:
  # 数据卷名称
  - name: data
    # 数据宿主机卷路径
    hostPath:
      # 指定宿主机数据卷路径
      path: /data

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod2
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.10
# hostport管理
    ports:
# 指定http
    - name: http
# 指定端口
      containerPort: 80
# hsotip监听IP，可通过哪些宿主级ip访问
      hostIP: 0.0.0.0
# 宿主级暴露端口，它会映射到containerport的容器端口
      hostPort: 89
# 指定协议类型
      protocol: TCP

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod2
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.10
# hostport管理
    ports:
# 指定http
    - name: http
# 指定端口
      containerPort: 80
# hsotip监听IP，可通过哪些宿主级ip访问
      hostIP: 0.0.0.0
# 宿主级暴露端口，它会映射到containerport的容器端口
      hostPort: 89
# 指定协议类型
      protocol: TCP

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod2
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.10
# hostport管理
    ports:
# 指定http
    - name: http
# 指定端口
      containerPort: 80
# hsotip监听IP，可通过哪些宿主级ip访问
      hostIP: 0.0.0.0
# 宿主级暴露端口，它会映射到containerport的容器端口
      hostPort: 89
# 指定协议类型
      protocol: TCP

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - name: http
    protocol: TCP
    port: 888
    targetPort: 80
  clusterIP: "10.10.10.11"

apiVersion: v1
kind: Service
metadata:
  name: nginx-service2
  labels:
  app: nginx
spec:
  selector:
    app: nginx
  ports:
  - name: http
    port: 8080
    targetPort: 80
# 服务类型
  type: NodePort

apiVersion: v1
kind: Service
metadata:
  name: nginx-service2
  labels:
  app: nginx
spec:
  selector:
    app: nginx
  ports:
  - name: http
    port: 8080
    targetPort: 80
# 服务类型
  type: NodePort