Dry Run

The dry run feature is a very useful way to check the correctness of the application configuration and definitions. It will render the application and print the output resources that checked on the service side. If the definitions(component, trait) is invalid, the dry run will print the error message.

When you do the following things, you’d better use dry-run.

  • Create or update an application.
  • Create or update the definition, and dry run some example applications.

There is a simple application:

  1. kind: Application
  2. apiVersion: core.oam.dev/v1beta1
  3. metadata:
  4.   name: webservice-app
  5. spec:
  6.   components:
  7.     - name: frontend
  8.       type: webservice
  9.       properties:
  10.         image: oamdev/testapp:v1
  11.         cmd: ["node", "server.js"]
  12.         ports:
  13.           - port: 8080
  14.             expose: true
  15.       traits:
  16.         - type: scaler
  17.           properties:
  18.             replicas: 1

Copy it and write a file app.yaml, execute the following command, and then the resources will be printed.

  1. vela dry-run app.yaml

expected output

  1. ---
  2. # Application(webservice-app) -- Component(frontend) 
  3. ---
  5. apiVersion: apps/v1
  6. kind: Deployment
  7. metadata:
  8.   annotations: {}
  9.   labels:
  10.     app.oam.dev/appRevision: ""
  11.     app.oam.dev/component: frontend
  12.     app.oam.dev/name: webservice-app
  13.     app.oam.dev/namespace: default
  14.     app.oam.dev/resourceType: WORKLOAD
  15.     workload.oam.dev/type: webservice
  16.   name: frontend
  17.   namespace: default
  18. spec:
  19.   replicas: 1
  20.   selector:
  21.     matchLabels:
  22.       app.oam.dev/component: frontend
  23.   template:
  24.     metadata:
  25.       labels:
  26.         app.oam.dev/component: frontend
  27.         app.oam.dev/name: webservice-app
  28.     spec:
  29.       containers:
  30.       - command:
  31.         - node
  32.         - server.js
  33.         image: oamdev/testapp:v1
  34.         name: frontend
  35.         ports:
  36.         - containerPort: 8080
  37.           name: port-8080
  38.           protocol: TCP
  40. ---
  41. ## From the auxiliary workload 
  42. apiVersion: v1
  43. kind: Service
  44. metadata:
  45.   annotations: {}
  46.   labels:
  47.     app.oam.dev/appRevision: ""
  48.     app.oam.dev/component: frontend
  49.     app.oam.dev/name: webservice-app
  50.     app.oam.dev/namespace: default
  51.     app.oam.dev/resourceType: TRAIT
  52.     trait.oam.dev/resource: webserviceExpose
  53.     trait.oam.dev/type: AuxiliaryWorkload
  54.   name: frontend
  55.   namespace: default
  56. spec:
  57.   ports:
  58.   - name: port-8080
  59.     port: 8080
  60.     targetPort: 8080
  61.   selector:
  62.     app.oam.dev/component: frontend
  63.   type: ClusterIP
  65. ---

If we set the expose field of the port as false, the output resources do not include the Service. If we set the replicas field as “1”, the output will be an error message:

  1. Error: validate application: ./app.yaml by dry-run: admission webhook "validating.core.oam.dev.v1beta1.applications" denied the request: field "schematic": Invalid value error encountered, cannot evaluate trait "scaler": invalid template of trait scaler after merge with parameter and context: parameter.replicas: conflicting values (*1 | int) and "1" (mismatched types int and string) (and 1 more errors).

This means the replicas field is int type but we provide a string value, this application configuration is not valid.

Dry Run - 图1提示

Override/topology Policies and deploy workflow are supported in v1.7.0+ now. While there’re still some limitation that dry-run with policy and workflow will only take override, topology policies and deploy workflow step into considerations. Other workflow steps will be ignored.

Let’s take the following application as example, the application explicitly specify override, topology policies and deploy workflow step.

  1. apiVersion: core.oam.dev/v1beta1
  2. kind: Application
  3. metadata:
  4.   name: first-vela-app
  5. spec:
  6.   components:
  7.     - name: express-server
  8.       type: webservice
  9.       properties:
  10.         image: oamdev/hello-world
  11.         ports:
  12.          - port: 8000
  13.            expose: true
  14.       traits:
  15.         - type: scaler
  16.           properties:
  17.             replicas: 1
  18.   policies:
  19.     - name: target-default
  20.       type: topology
  21.       properties:
  22.         clusters: ["local"]
  23.         namespace: "default"
  24.     - name: target-prod
  25.       type: topology
  26.       properties:
  27.         clusters: ["local"]
  28.         namespace: "prod"
  29.     - name: deploy-ha
  30.       type: override
  31.       properties:
  32.         components:
  33.           - type: webservice
  34.             traits:
  35.               - type: scaler
  36.                 properties:
  37.                   replicas: 5
  38.   workflow:
  39.     steps:
  40.       - name: deploy2default
  41.         type: deploy
  42.         properties:
  43.           policies: ["target-default"]
  44.       - name: manual-approval
  45.         type: suspend
  46.       - name: deploy2prod
  47.         type: deploy
  48.         properties:
  49.           policies: ["target-prod", "deploy-ha"]

Dry run will produce rendered results for both deploy2default and deploy2prod deploy steps as below:

expected output

  1. ---
  2. # Application(first-vela-app with topology target-default) -- Component(express-server) 
  3. ---
  5. apiVersion: apps/v1
  6. kind: Deployment
  7. metadata:
  8.   annotations: {}
  9.   labels:
  10.     app.oam.dev/appRevision: ""
  11.     app.oam.dev/component: express-server
  12.     app.oam.dev/name: first-vela-app
  13.     app.oam.dev/namespace: default
  14.     app.oam.dev/resourceType: WORKLOAD
  15.     workload.oam.dev/type: webservice
  16.   name: express-server
  17.   namespace: default
  18. spec:
  19.   replicas: 1
  20.   selector:
  21.     matchLabels:
  22.       app.oam.dev/component: express-server
  23.   template:
  24.     metadata:
  25.       labels:
  26.         app.oam.dev/component: express-server
  27.         app.oam.dev/name: first-vela-app
  28.     spec:
  29.       containers:
  30.       - image: oamdev/hello-world
  31.         name: express-server
  32.         ports:
  33.         - containerPort: 8000
  34.           name: port-8000
  35.           protocol: TCP
  37. ---
  38. ## From the auxiliary workload 
  39. apiVersion: v1
  40. kind: Service
  41. metadata:
  42.   annotations: {}
  43.   labels:
  44.     app.oam.dev/appRevision: ""
  45.     app.oam.dev/component: express-server
  46.     app.oam.dev/name: first-vela-app
  47.     app.oam.dev/namespace: default
  48.     app.oam.dev/resourceType: TRAIT
  49.     trait.oam.dev/resource: webserviceExpose
  50.     trait.oam.dev/type: AuxiliaryWorkload
  51.   name: express-server
  52.   namespace: default
  53. spec:
  54.   ports:
  55.   - name: port-8000
  56.     port: 8000
  57.     targetPort: 8000
  58.   selector:
  59.     app.oam.dev/component: express-server
  60.   type: ClusterIP
  62. ---
  64. ---
  65. # Application(first-vela-app with topology target-prod) -- Component(express-server) 
  66. ---
  68. apiVersion: apps/v1
  69. kind: Deployment
  70. metadata:
  71.   annotations: {}
  72.   labels:
  73.     app.oam.dev/appRevision: ""
  74.     app.oam.dev/component: express-server
  75.     app.oam.dev/name: first-vela-app
  76.     app.oam.dev/namespace: default
  77.     app.oam.dev/resourceType: WORKLOAD
  78.     workload.oam.dev/type: webservice
  79.   name: express-server
  80.   namespace: default
  81. spec:
  82.   replicas: 5
  83.   selector:
  84.     matchLabels:
  85.       app.oam.dev/component: express-server
  86.   template:
  87.     metadata:
  88.       labels:
  89.         app.oam.dev/component: express-server
  90.         app.oam.dev/name: first-vela-app
  91.     spec:
  92.       containers:
  93.       - image: oamdev/hello-world
  94.         name: express-server
  95.         ports:
  96.         - containerPort: 8000
  97.           name: port-8000
  98.           protocol: TCP
  100. ---
  101. ## From the auxiliary workload 
  102. apiVersion: v1
  103. kind: Service
  104. metadata:
  105.   annotations: {}
  106.   labels:
  107.     app.oam.dev/appRevision: ""
  108.     app.oam.dev/component: express-server
  109.     app.oam.dev/name: first-vela-app
  110.     app.oam.dev/namespace: default
  111.     app.oam.dev/resourceType: TRAIT
  112.     trait.oam.dev/resource: webserviceExpose
  113.     trait.oam.dev/type: AuxiliaryWorkload
  114.   name: express-server
  115.   namespace: default
  116. spec:
  117.   ports:
  118.   - name: port-8000
  119.     port: 8000
  120.     targetPort: 8000
  121.   selector:
  122.     app.oam.dev/component: express-server
  123.   type: ClusterIP
  125. ---

Each deploy workflow step with topology policy will render individual result.

It can be a bit redundant for you as you may just need to dry run for one environment at a time. The, you can use the external workflow feature like below.

Firstly, define policy and workflow as below in individual files:

  • The target-prod.yaml and ha.yaml corresponding to the production environment.

    1. # target-prod.yaml
    2. apiVersion: core.oam.dev/v1alpha1
    3. kind: Policy
    4. metadata:
    5.   name: target-prod
    6. type: topology
    7. properties:
    8.   clusters: ["local"]
    9.   namespace: "prod"
    1. # ha.yaml
    2. apiVersion: core.oam.dev/v1alpha1
    3. kind: Policy
    4. metadata:
    5.   name: ha
    6. type: override
    7. properties:
    8.   components:
    9.   - type: webservice
    10.     traits:
    11.     - type: scaler
    12.       properties:
    13.         replicas: 5

  • The prod-workflow.yaml can glue them together.

    1. # prod-workflow.yaml
    2. apiVersion: core.oam.dev/v1alpha1
    3. kind: Workflow
    4. metadata:
    5.   name: deploy-prod
    6. steps:
    7.   - type: deploy
    8.     name: deploy-prod
    9.     properties:
    10.       policies: ["ha", "target-prod"]

  • Then the application can reference the workflow as below.

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: first-vela-app
    5. spec:
    6.   components:
    7.     - name: express-server
    8.       type: webservice
    9.       properties:
    10.         image: oamdev/hello-world
    11.         ports:
    12.         - port: 8000
    13.           expose: true
    14.       traits:
    15.         - type: scaler
    16.           properties:
    17.             replicas: 1
    18.   workflow:
    19.     ref: deploy-prod

The dry run command can be:

  1. vela dry-run -f app.yaml -f target-prod.yaml -f ha.yaml -f prod-workflow.yaml

Then, the dry-run results will only contain resources in the production environment.

expected output

  1. ---
  2. # Application(first-vela-app with topology target-prod) -- Component(express-server) 
  3. ---
  5. apiVersion: apps/v1
  6. kind: Deployment
  7. metadata:
  8.   annotations: {}
  9.   labels:
  10.     app.oam.dev/appRevision: ""
  11.     app.oam.dev/component: express-server
  12.     app.oam.dev/name: first-vela-app
  13.     app.oam.dev/namespace: default
  14.     app.oam.dev/resourceType: WORKLOAD
  15.     workload.oam.dev/type: webservice
  16.   name: express-server
  17.   namespace: default
  18. spec:
  19.   replicas: 5
  20.   selector:
  21.     matchLabels:
  22.       app.oam.dev/component: express-server
  23.   template:
  24.     metadata:
  25.       labels:
  26.         app.oam.dev/component: express-server
  27.         app.oam.dev/name: first-vela-app
  28.     spec:
  29.       containers:
  30.       - image: oamdev/hello-world
  31.         name: express-server
  32.         ports:
  33.         - containerPort: 8000
  34.           name: port-8000
  35.           protocol: TCP
  37. ---
  38. ## From the auxiliary workload 
  39. apiVersion: v1
  40. kind: Service
  41. metadata:
  42.   annotations: {}
  43.   labels:
  44.     app.oam.dev/appRevision: ""
  45.     app.oam.dev/component: express-server
  46.     app.oam.dev/name: first-vela-app
  47.     app.oam.dev/namespace: default
  48.     app.oam.dev/resourceType: TRAIT
  49.     trait.oam.dev/resource: webserviceExpose
  50.     trait.oam.dev/type: AuxiliaryWorkload
  51.   name: express-server
  52.   namespace: default
  53. spec:
  54.   ports:
  55.   - name: port-8000
  56.     port: 8000
  57.     targetPort: 8000
  58.   selector:
  59.     app.oam.dev/component: express-server
  60.   type: ClusterIP
  62. ---

Moreover, you can use --merge flag to merge external policies and workflow when application file is not reference to them.

For example, you can define the application as below, the only difference is there’s no workflow field.

  1. # app.yaml
  2. apiVersion: core.oam.dev/v1beta1
  3. kind: Application
  4. metadata:
  5.   name: first-vela-app
  6. spec:
  7.   components:
  8.     - name: express-server
  9.       type: webservice
  10.       properties:
  11.         image: oamdev/hello-world
  12.         ports:
  13.          - port: 8000
  14.            expose: true
  15.       traits:
  16.         - type: scaler
  17.           properties:
  18.             replicas: 1

the workflow and policy can be defined the same way

  1. # workflow.yaml
  2. apiVersion: core.oam.dev/v1alpha1
  3. kind: Workflow
  4. metadata:
  5.   name: deploy-demo
  6. steps:
  7.   - type: deploy
  8.     name: deploy-prod
  9.     properties:
  10.       policies: ["target-prod"]
  1. # target-prod.yaml
  2. apiVersion: core.oam.dev/v1alpha1
  3. kind: Policy
  4. metadata:
  5.   name: target-prod
  6. type: topology
  7. properties:
  8.   clusters: ["local"]
  9.   namespace: "prod"

If you don’t use --merge flag in this way, it will report warnings as below.

  1. vela dry-run -f app.yaml -f target-prod.yaml -f workflow.yaml

result with warning messages

  1. WARNING: workflow deploy-demo not referenced by application
  3. WARNING: policy target-prod not referenced by application
  5. ---
  6. # Application(default) -- Component(express-server) 
  7. ---
  9. apiVersion: apps/v1
  10. kind: Deployment
  11. metadata:
  12.   annotations: {}
  13.   labels:
  14.     app.oam.dev/appRevision: ""
  15.     app.oam.dev/component: express-server
  16.     app.oam.dev/name: first-vela-app
  17.     app.oam.dev/namespace: default
  18.     app.oam.dev/resourceType: WORKLOAD
  19.     workload.oam.dev/type: webservice
  20.   name: express-server
  21.   namespace: default
  22. spec:
  23.   replicas: 1
  24.   selector:
  25.     matchLabels:
  26.       app.oam.dev/component: express-server
  27.   template:
  28.     metadata:
  29.       labels:
  30.         app.oam.dev/component: express-server
  31.         app.oam.dev/name: first-vela-app
  32.     spec:
  33.       containers:
  34.       - image: oamdev/hello-world
  35.         name: express-server
  36.         ports:
  37.         - containerPort: 8000
  38.           name: port-8000
  39.           protocol: TCP
  41. ---
  42. ## From the auxiliary workload 
  43. apiVersion: v1
  44. kind: Service
  45. metadata:
  46.   annotations: {}
  47.   labels:
  48.     app.oam.dev/appRevision: ""
  49.     app.oam.dev/component: express-server
  50.     app.oam.dev/name: first-vela-app
  51.     app.oam.dev/namespace: default
  52.     app.oam.dev/resourceType: TRAIT
  53.     trait.oam.dev/resource: webserviceExpose
  54.     trait.oam.dev/type: AuxiliaryWorkload
  55.   name: express-server
  56.   namespace: default
  57. spec:
  58.   ports:
  59.   - name: port-8000
  60.     port: 8000
  61.     targetPort: 8000
  62.   selector:
  63.     app.oam.dev/component: express-server
  64.   type: ClusterIP
  66. ---

In this case, the policy and workflow do not take effect. Because those are not referenced by the application and being viewed as standalone files and ignored.

So to make those external files work, please provide “—merge” flag as below:

  1. vela dry-run -f app.yaml -f target-prod.yaml -f workflow.yaml --merge

Then the application will be glued with external policies and workflows even no reference exists.

expected ouput

  1. ---
  2. # Application(first-vela-app with topology target-prod) -- Component(express-server) 
  3. ---
  5. apiVersion: apps/v1
  6. kind: Deployment
  7. metadata:
  8.   annotations: {}
  9.   labels:
  10.     app.oam.dev/appRevision: ""
  11.     app.oam.dev/component: express-server
  12.     app.oam.dev/name: first-vela-app
  13.     app.oam.dev/namespace: default
  14.     app.oam.dev/resourceType: WORKLOAD
  15.     workload.oam.dev/type: webservice
  16.   name: express-server
  17.   namespace: default
  18. spec:
  19.   replicas: 1
  20.   selector:
  21.     matchLabels:
  22.       app.oam.dev/component: express-server
  23.   template:
  24.     metadata:
  25.       labels:
  26.         app.oam.dev/component: express-server
  27.         app.oam.dev/name: first-vela-app
  28.     spec:
  29.       containers:
  30.       - image: oamdev/hello-world
  31.         name: express-server
  32.         ports:
  33.         - containerPort: 8000
  34.           name: port-8000
  35.           protocol: TCP
  37. ---
  38. ## From the auxiliary workload 
  39. apiVersion: v1
  40. kind: Service
  41. metadata:
  42.   annotations: {}
  43.   labels:
  44.     app.oam.dev/appRevision: ""
  45.     app.oam.dev/component: express-server
  46.     app.oam.dev/name: first-vela-app
  47.     app.oam.dev/namespace: default
  48.     app.oam.dev/resourceType: TRAIT
  49.     trait.oam.dev/resource: webserviceExpose
  50.     trait.oam.dev/type: AuxiliaryWorkload
  51.   name: express-server
  52.   namespace: default
  53. spec:
  54.   ports:
  55.   - name: port-8000
  56.     port: 8000
  57.     targetPort: 8000
  58.   selector:
  59.     app.oam.dev/component: express-server
  60.   type: ClusterIP
  62. ---

You can refer to the Dry run command for more command line use cases.

dry-run

Clicking the Deploy button to open the workflow selector dialog. You could select a workflow(every workflow corresponding to an environment) and click the DryRun button to execute a dry run. If passed, the result is like this

dry-run-successfully

The result report is different from the CLI, there is a complete application configuration that is generated from the application metadata, you could check it. Different environments may have different application configurations.

Last updated on 2023年8月4日 by Daniel Higuero