Workflow Step Definition

    Before reading this section, make sure you have understood the concept of WorkflowStepDefinition in KubeVela and learned the .

    In this section, we will introduce how to customize the workflow step in Application by using CUE through WorkflowStepDefinition.

    We can generate WorkflowStepDefinition CUE file with command vela def <def-name> --type workflow-step > <def-name>.cue.

    Let’s take a custom step for sending an HTTP request as an example, first, initialize the Definition file:

    After initialization, we can see the following in request.cue:

    1. request: {
    2.     alias: ""
    3.     annotations: {}
    4.     attributes: {}
    5.     description: "Send request to the url"
    6.     labels: {}
    7.     type: "workflow-step"
    8. }
    10. template: {
    11. }

    Inside the template is the execution logic for this workflow step. We can define parameter in template to receive the parameters passed in by the user:

    At the same time, KubeVela also provides the vela/op package by default, which contains a series of built-in workflow CUE actions, such as: sending HTTP requests, operating K8s resources, printing logs, etc.

    Now we can import KubeVela’s built-in vela/op package and CUE’s official encoding/json, use op.#HTTPDo to send HTTP requests according to the user’s parameters, and use json.Marshal() to marshal the data.

    1. import (
    2.     "vela/op"
    3.     "encoding/json"
    4. )
    6. request: {
    7.     alias: ""
    8.     annotations: {}
    9.     attributes: {}
    10.     description: "Send request to the url"
    12.     type: "workflow-step"
    14. template: {
    15.     http: op.#HTTPDo & {
    16.         method: parameter.method
    17.         url:    parameter.url
    18.         request: {
    19.             if parameter.body != _|_ {
    20.                 body: json.Marshal(parameter.body)
    21.             }
    22.             if parameter.header != _|_ {
    23.                 header: parameter.header
    24.             }
    25.         }
    26.     }
    27.     parameter: {
    28.         url:    string
    29.         method: *"GET" | "POST" | "PUT" | "DELETE"
    30.         body?: {...}
    31.         header?: [string]: string
    32.     }
    33. }

    If the HTTP request returns a status code greater than 400, we expect this step to be failed. Use op.#Fail to fail this step, and the definition is like:

    Use vela def apply -f request.cue to deploy this Definition to the cluster, then we can use this custom step directly in the Application.

    Deploy the following Application: The first step of the workflow will send an HTTP request to get the information of the KubeVela repository; at the same time, this step will use the star number of the KubeVela repository as the Output, the next step will use this Output as a parameter, and sent it as message to the Slack:

    tip

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: request-http
    5.   namespace: default
    6. spec:
    7.   components: []
    8.     steps:
    9.     - name: request
    10.       type: request
    11.       properties:
    13.       outputs:
    14.         - name: stars
    15.           valueFrom: |
    16.             import "strconv"
    17.             "Current star count: " + strconv.FormatInt(response["stargazers_count"], 10)
    18.     - name: notification
    19.       type: notification
    20.       inputs:
    21.         - from: stars
    22.           parameterKey: slack.message.text
    23.       properties:
    24.         slack:
    25.           url:
    26.             value: <your slack url>

    If you want to wait a period of time in a workflow step until a certain condition is met, or until the status of a resource becomes ready, you can use op.#ConditionalWait.

    Take the status of waiting for a Deployment as an example, use op.#Apply to deploy a Deployment, and then use op.#ConditionalWait to wait for the status of the Deployment to become ready:

    KubeVela allows you to reference some runtime data via the context keyword.

    In a workflow step definition, you can use the following context data:

    KubeVela is fully programmable through CUE, while it leverages Kubernetes as a control plane and is consistent with the API in YAML.

    Therefore, the CUE Definition will be translated into the Kubernetes API when applied to the cluster.

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: WorkflowStepDefinition
    3. metadata:
    4.   annotations:
    5.     definition.oam.dev/description: <Function description>
    6. spec:
    7.   schematic:
    8.     cue: # Details of workflow steps defined by CUE language
    9.       template: <CUE format template>

    You can check the following resources for more examples:

    • Definitions defined in addons in the .