Batch workflow syntax

Batch workflow

Batch workflows are located in the .neuro/<batch-name>.yml or .neuro/<batch-name>.yaml file under the project's root. The config filename should be lowercase and not start with a digit if the id attribute is not specified. The following YAML attributes are supported:

kind

Required The workflow kind, must be batch for batch workflows.

id

Expression contexts: This attribute cannot contain expressions.
Identifier of the workflow. By default, the id is generated from the filename of the workflow config, with hyphens being (-) replaced with underscores (_). It's available as a ${{ flow.flow_id }} in experssions.

title

Workflow title.
Expression contexts: This attribute only allows expressions that don't access contexts.

defaults

A map of default settings that will be applied to all tasks in the workflow. You can override these global default settings for specific tasks.

defaults.env

A mapping of environment variables that are available to all tasks in the workflow. You can also set environment variables that are only available to a task. For more information, see tasks.env.
When two or more environment variables are defined with the same name, neuro-flow uses the most specific environment variable. For example, an environment variable defined in a task will override the workflow default.
Example:
1
env:
2
SERVER: production
Copied!
This attribute also supports dictionaries as values:
1
env: ${{ {'global_a': 'val-a', 'global_b': 'val-b'} }}
Copied!
Expression contexts: flow context, params context.

defaults.life_span

The default lifespan for jobs ran by the workflow. It can be overridden by tasks.life_span. If not set, the default task lifespan is 1 day. The lifespan value can be one of the following:
  • A float number representing the amount of seconds (3600 represents an hour)
  • A string of the following format: 1d6h15m (1 day, 6 hours, 15 minutes)
For lifespan-disabling emulation, use an arbitrary large value (e.g. 365d). Keep in mind that this may be dangerous, as a forgotten job will consume cluster resources.
life span shorter than 1 minute is forbidden.
Example:
1
defaults:
2
life_span: 14d
Copied!
Expression contexts: flow context, params context.

defaults.preset

The default preset name used by all tasks if not overridden by tasks.preset. The system-wide default preset is used if both defaults.preset and tasks.preset are omitted.
Example:
1
defaults:
2
preset: gpu-small
Copied!

defaults.volumes

Volumes that will be mounted to all tasks by default.
Example:
1
defaults:
2
volumes:
3
- storage:some/dir:/mnt/some/dir
4
- storage:some/another/dir:/mnt/some/another/dir
Copied!
Default volumes are not passed to actions.
Expression contexts: flow context, params context.

defaults.schedule_timeout

The default timeout for task scheduling. See tasks.schedule_timeout for more information.
The attribute accepts the following values:
  • A float number representing the amount of seconds (3600 represents an hour)
  • A string of the following format: 1d6h15m45s (1 day, 6 hours, 15 minutes, 45 seconds).
The cluster-wide timeout is used if both default.schedule_timeout and tasks.schedule_timeout are omitted.
Example:
1
defaults:
2
schedule_timeout: 1d # don't fail until tomorrow
Copied!
Expression contexts: flow context, params context.

defaults.tags

A list of tags that are added to every task created by the workflow. A particular task definition can extend this global list by tasks.tags.
Example:
1
defaults:
2
tags: [tag-a, tag-b]
Copied!
This attribute supports lists as values.

defaults.workdir

The default working directory for tasks created by this workflow. See tasks.workdir for more information.
Expression contexts: flow context, params context.

defaults.fail_fast

When set to true, the system cancels all in-progress tasks if any one of them fails. It can be overridden by tasks.strategy.fail_fast. This is set to true by default.
Example:
1
defaults:
2
fail_fast: false
Copied!

defaults.max_parallel

The maximum number of tasks that can run simultaneously during flow execution. By default, there is no limit.
Example:
1
defaults:
2
max_parallel: 4
Copied!

defaults.cache

A mapping that defines how task outputs are cached. It can be overridden by tasks.cache``

defaults.cache.strategy

The default strategy to use for caching. Available options are:
  • "none" Don't use caching at all.
  • "default" The basic caching algorithm that reuses cached outputs in case task definitions and all expression contexts available in the task's expressions are the same.
Default: "default"
Example:
1
cache:
2
strategy: "default"
Copied!

defaults.cache.life_span

The default cache invalidation duration. The attribute accepts the following values:
  • A float number representing the amount of seconds (3600 represents an hour)
  • A string of the following format: 1d6h15m45s (1 day, 6 hours, 15 minutes, 45 seconds)
Default: 14d (two weeks).
If you decrease this value and re-run the flow, neuro-flow will ignore cache entries that were added longer ago than the new cache.life_span value states.
Example:
1
cache:
2
life_span: 31d # Cache is valid for one month
Copied!

images

A mapping of image definitions used by the batch workflow.
If the specified image reference is available at the Neu.ro registry and the .force_rebuild flag is not set, then Neu.ro Flow will not attempt to build the image from scratch. If this flag is set or the image is not in the registry, then the platform will start buliding the image.
The images section is not required. A task can specify the image name in a plain string without referring to the ${{ images.my_image.ref }} context.

images.<image-id>

The key image-id is a string and its value is a map of an image's configuration data. You must replace <image-id> with a string that is unique to the images object. <image-id> must start with a letter and contain only alphanumeric characters or underscore symbols _. Dash - is not allowed.

images.<image-id>.ref

Required Image reference that can be used in the tasks.image expression.
Example of a self-hosted image:
1
images:
2
my_image:
3
ref: image:my_image:latest
Copied!
This can only use locally accessible functions (such as hash_files). Its value will be calculated before the remote executor starts.
Example of external image:
1
images:
2
python:
3
ref: python:3.9.0
Copied!
Use the embedded hash_files() function to generate the built image's tag based on its content.
Example of an auto-calculated stable hash:
1
images:
2
my_image:
3
ref: image:my_image:${{ hash_files('Dockerfile', 'requirements/*.txt', 'modules/**/*.py') }}
Copied!
Expression contexts: flow context.

images.<image-id>.context

The Docker context used to build an image. Can be either local path (e.g. ${{ flow.workspace / 'some/dir' }}) or a remote volume spec (e.g. storage:subdir/${{ flow.flow_id }}). If it's a local path, it cannot use anything that's not available at the beginning of a bake (for example, action inputs). If it's a remote path, usage of dynamic values is allowed. Local context will be automatically uploaded to storage during the "local actions" step of the bake.
Example:
1
images:
2
my_image:
3
context: path/to/context
Copied!
neuro-flow cannot build images without the context, but can address pre-built images using images.<image-id>.ref
Expression contexts: flow context.

images.<image-id>.dockerfile

An optional Docker file name used for building images, Dockerfile by default.
Works almost the same as .context - if it's a local path, dynamic values are forbidden and it's automatically uploaded. If it's a remote path, then dynamic values are allowed.
Example:
1
images:
2
my_image:
3
dockerfile: MyDockerfile
Copied!
Expression contexts: flow context.

images.<image-id>.build_args

A list of optional build arguments passed to the image builder. See Docker documentation for details. Supports dynamic values such as action inputs.
Example:
1
images:
2
my_image:
3
build_args:
4
- ARG1=val1
5
- ARG2=val2
Copied!
Expression contexts: flow context.

images.<image-id>.env

A mapping of environment variables passed to the image builder. Supports dynamic values such as action inputs.
Example:
1
images:
2
my_image:
3
env:
4
ENV1: val1
5
ENV2: val2
Copied!
This attribute also supports dictionaries as values:
1
images:
2
my_image:
3
env: ${{ {'ENV1': 'val1', 'ENV2': 'val2'} }}
Copied!
Expression contexts: flow context.

images.<image-id>.volumes

A list of volume references mounted to the image building process. Supports dynamic values such as action inputs.
Example:
1
images:
2
my_image:
3
volumes:
4
- storage:folder1:/mnt/folder1:ro
5
- storage:folder2:/mnt/folder2
6
- volumes.volume_id.ref
Copied!
This attribute also supports lists as values:
1
images:
2
my_image:
3
volumes: ${{ ['ubuntu', volumes.volume_id.ref] }}
Copied!
Expression contexts: flow context.

images.<image-name>.force_rebuild

If this flag is enabled, the referenced image will be rebuilt from scratch for each bake.
Example:
1
images:
2
my_image:
3
force_rebuild: true
Copied!

params

Mapping of key-value pairs that have default values.
This attribute describes a set of names and default values of parameters accepted by a flow.
Parameters can be specified in short and long forms.
The short form is compact but only allows to specify the names and default values of parameters:
1
params:
2
name1: default1
3
name2: ~ # None by default
4
name3: "" # Empty string by default
Copied!
The long form allows to additionally specify parameter descriptions. This can be useful for neuro-flow bake command introspection, shell autocompletion, and generation of more detailed error messages:
1
params:
2
name1:
3
default: default1
4
descr: The name1 description
5
name2:
6
default: ~
7
descr: The name2 description
8
name3:
9
default: ""
10
descr: The name3 description
Copied!
This attribute can be overridden from the command line in two ways while running a batch in Neuro CLI:
  • Specifying the parameters through --param.
1
$ neuro-flow bake <batch-id> --param name1 val1 --param name2 val2
Copied!
  • Pointing to a YAML file with parameter descriptions through --meta-from-file.
1
$ neuro-flow bake --meta-from-file <some-file>
Copied!
The file should have the following structure:
1
param1: value
2
param2: value
3
...
Copied!
Expression contexts: This attribute only allows expressions that don't access contexts.

images

A mapping of image definitions used by this workflow.
Unlike live flow images, batch flow images cannot be built using neuro-flow build <image-id>.
The images section is not required. A task can specify the image name in a plain string without referring to the ${{ images.my_image.ref }} context.
However, this section exists for convenience: there is no need to repeat yourself if you can just point the image reference everywhere in the YAML.
The following fields are disabled in batch workflows and will be ignored:
  • images.<image-id>.context
  • images.<image-id>.dockerfile
  • images.<image-id>.build_args
  • images.<image-id>.env
  • images.<image-id>.volumes

images.<image-id>

The key image-id is a string and its value is a map of the task's configuration data. You must replace <image-id> with a string that is unique to the images object. <image-id> must start with a letter and contain only alphanumeric characters or underscore symbols _. Dash - is not allowed.

images.<image-id>.ref

Required Image reference that can be used in the tasks.image expression.
You can use the image definition to address images hosted either on the Neu.ro registry or Docker Hub.
Example:
1
images:
2
my_image:
3
ref: image:my_image:latest # Neu.ro registry hosted iamge
4
python:
5
ref: python:3.9.0 # Docker Hub hosted image
Copied!
Expression contexts: flow context, params context.

volumes

A mapping of volume definitions available in this workflow. A volume defines a link between the Neu.ro storage folder and a remote folder that can be mounted to a task.
Unlike live flow volumes, batch flow volumes cannot be synchronized by neuro-flow upload and neuro-flow download commands. They can only be mounted to a task by using task.volumes attribute.
The following fields are disabled in batch workflows and will cause an error:
  • volumes.<volume-id>.local

volumes.<volume-id>

The key volume-id is a string and its value is a map of the volume's configuration data. You must replace <volume-id> with a string that is unique to the volumes object. The <volume-id> must start with a letter and contain only alphanumeric characters or underscore symbols _. Dash - is not allowed.

volumes.<volume-id>.remote

Required Volume URI on the Neu.ro Storage.
Example:
1
volumes:
2
folder:
3
remote: storage:path/to/folder
Copied!
Expression contexts: flow context, params context.

volumes.<volume-id>.mount

Required Mount path inside a task.
Example:
1
volumes:
2
folder:
3
mount: /mnt/folder
Copied!
Expression contexts: flow context, params context.

volumes.<volume-id>.read_only

The volume is mounted as read-only by default if this attribute is enabled, read-write mode is used otherwise.
Example:
1
volumes:
2
folder:
3
read_only: true
Copied!
Expression contexts: flow context, params context.

tasks

List of tasks and action calls that this batch workflow contains. Unlike jobs in live workflows, all tasks are executed with one command in the order specified by tasks.needs. To start execution, run neuro-flow bake <batch-id>.
Example:
1
tasks:
2
- id: task_1
3
- id: task_2
4
- id: task_3
Copied!

Attributes for tasks and action calls

The attributes described in this section can be applied both to plain tasks and action calls. To simplify reading, this section uses the term "task" instead of "task or action call".

tasks.id

A unique identifier for the task. It's used to reference the task in tasks.needs. The value must start with a letter and only contain alphanumeric characters or underscore symbols (_). The dash symbol (-) is not allowed.
It is impossible to refer to tasks without an ID inside the workflow file, but you can refer to them as task-<num> in the command line output. Here, <num> is an index from the tasks list.
Expression contexts: matrix context.

tasks.needs

An array of strings identifying all tasks that must be completed or running before this task will run. If a task fails, all tasks that need it are skipped unless the task uses a tasks.enable statement that causes it to ignore the dependency failure. By default, tasks.needs is set to the previous task in the tasks list. In case the previous task has matrix enabled, the current task will only run after all matrix tasks are completed. This property also specifies what entries are available in the needs context.
Example 1:
1
tasks:
2
- id: task_1
3
- id: task_2
4
needs: [tasks_1]
5
- id: task_3
6
needs: [tasks_2]
Copied!
In this case, tasks will be executed in the following order:
  1. 1.
    task_1
  2. 2.
    task_2
  3. 3.
    task_3
The order is the same as in the default behavior without needs.
Example 2:
1
tasks:
2
- id: task_1
3
- id: task_2
4
needs: []
5
- id: task_3
6
needs: [task_1, tasks_2]
Copied!
In this case, tasks will be executed in the following order:
  1. 1.
    task_1 and task_2 (simultaneously)
  2. 2.
    task_3
Example 3
1
tasks:
2
- id: task_1
3
- id: task_2
4
needs: []
5
- id: task_3
6
needs:
7
task_1: running
8
task_2: running
Copied!
Here, task_3 will only be executed if task_1 and task_2 are already running.
The following are two different ways to specify needed tasks:
1
needs:
2
task_1: running
Copied!
1
needs:
2
${{ 'task_1' }}: running
Copied!
You can use neuro-flow inspect --view BAKE_ID to view the graph of running batch tasks converted to a PDF file.
Expression contexts: matrix context.

tasks.enable

The flag that prevents a task from running unless a condition is met. To learn how to write conditions, refer to expression syntax. Default: ${{ success() }}
Example:
1
tasks:
2
- enable: ${{ always() }} # Run this task in any case
3
- enable: ${{ flow.id == "some-value" }} # Simple condition
Copied!

tasks.strategy

A mapping that defines a matrix and some auxiliary attributes to run multiple instances of the same task.

tasks.strategy.matrix

The matrix attribute defines a set of configurations with which to run a task. Each key in this mapping sets some variable that will be available in the matrix context in expressions of the corresponding task. Each value should be an array, and neuro-flow will start task variants with all possible combinations of items from these arrays. The matrix can generate 256 different tasks at most.
Example 1:
1
id: example_${{ matrix.param }}
2
strategy:
3
matrix:
4
param: [a, b]
Copied!
In this example, tasks with IDs example_a and example_b will be generated.
Example 2:
1
id: ${{ matrix.param1 }}_${{ matrix.param2 }}
2
strategy:
3
matrix:
4
param1: [a, b]
5
param2: [x, y]
Copied!
In this example, tasks with IDs a_x, a_y, b_x, b_y will be generated.
Auto-generated IDs for matrix tasks will have suffixes in the form of -<param-1>-<param-2>
Expression contexts: Matrix values only allows expressions that don't access contexts.

tasks.strategy.matrix.exclude

exclude is a list of combinations to remove from the matrix. These entries can be partial, in which case all matching combinations are excluded.
Example:
1
id: ${{ matrix.param1 }}_${{ matrix.param2 }}_${{ matrix.param3 }}
2
strategy:
3
matrix:
4
param1: [a, b]
5
param2: [x, y]
6
param3: [1, 2]
7
exclude:
8
- param1: a
9
param2: x
10
param3: 1
11
- param1: b
12
param2: y
Copied!
In this example, tasks with IDs a_x_2, a_y_1, a_y_2, b_x_1, b_x_2 will be generated.
Expression contexts: Matrix values only allows expressions that don't access contexts.

tasks.strategy.matrix.include

include is a list of combinations to add to the matrix. These entries cannot be partial. In case exclude is also set, include will be applied after it.
Example:
1
id: ${{ matrix.param1 }}_${{ matrix.param2 }}_${{ matrix.param3 }}
2
strategy:
3
matrix:
4
param1: [a, b]
5
param2: [x, y]
6
include:
7
- param1: a
8
param2: z
Copied!
In this example, tasks with IDs a_x, a_y, b_x, b_y, a_z will be generated.
Expression contexts: Matrix values only allows expressions that don't access contexts.

tasks.strategy.fail_fast

When set to true, the system cancels all in-progress tasks if this task or any of its matrix tasks fail. Default: true.
Expression contexts: flow context, params context, env context, tags context, volumes context, images context, strategy context (contains flow global values).

tasks.strategy.max_parallel

The maximum number of matrix tasks that can run simultaneously. By default, there is no limit.
Expression contexts: flow context, params context, env context, tags context, volumes context, images context, strategy context (contains flow global values).

tasks.cache

A mapping that defines how task outputs are cached.

tasks.cache.strategy

The strategy to use for caching of this task. Available options are:
  • "none" Don't use caching at all
  • "inherit" Use the flow default value from defaults.cache.stategy``
  • "default" The basic caching algorithm that reuses cached outputs in case task definition and all expression contexts available in task expressions are the same.
Default: "inherit"
Example:
1
cache:
2
strategy: "none"
Copied!

tasks.cache.life_span

The cache invalidation duration. This attribute can accept the following values:
  • A float number representing an amount of seconds
  • A string in the following format: 1d6h15m45s (1 day, 6 hours, 15 minutes, 45 seconds)
Defaults to defaults.cache.life_span if not specified.
If you decrease this value and re-run the flow, neuro-flow will ignore cache entries that were added longer ago than the new cache.life_span value specifies.
Example:
1
cache:
2
life_span: 31d # Cache is valid for one month
Copied!

Attributes for tasks

The attributes in this section are only applicable to plain tasks that are executed by running Docker images on the Neu.ro platform.

tasks.image

Required Each task is executed remotely on the Neu.ro cluster using a Docker image. The image can be hosted on Docker Hub (python:3.9 or ubuntu:20.04) or on the Neu.ro Registry (image:my_image:v2.3).
Example with a constant image string:
1
tasks:
2
- image: image:my_image:v2.3
Copied!
You may often want to use the reference to images.<image-id>.
Example with a reference to the images section:
1
tasks:
2
- image: ${{ images.my_image.ref }}
Copied!

tasks.cmd

A tasks executes either a command, a bash script, or a python script. The cmd, bash, and python are mutually exclusive: only one of the three is allowed at the same time. If none of these three attributes are specified, the CMD from the tasks.image is used.
The cmd attribute points to the command with optional arguments that is available in the executed tasks.image.
Example:
1
tasks:
2
- cmd: tensorboard --host=0.0.0.0
Copied!

tasks.bash

This attribute contains a bash script to run.
Using cmd to run a bash script can be tedious: you need to apply quotas to the executed script and set proper bash flags to fail on error.
The bash attribute is essentially a shortcut for cmd: bash -euo pipefail -c <shell_quoted_attr> .
This form is especially handy for executing complex multi-line bash scripts.
cmd, bash, and python are mutually exclusive.
bash should be pre-installed on the image to make this attribute work.
Example:
1
tasks:
2
- bash: |
3
for arg in {1..5}
4
do
5
echo "Step ${arg}"
6
sleep 1
7
done
Copied!

tasks.python

This attribute contains a python script to run.
Python is usually considered to be one of the best languages for scientific calculation. If you prefer writing simple inlined commands in python instead of bash, this notation is great for you.
The python attribute is essentially a shortcut for cmd: python3 -uc <shell_quoted_attr> .
cmd, bash, and python are mutually exclusive.
python3 should be pre-installed on the image to make this attribute work.
Example:
1
tasks:
2
- python: |
3
import sys
4
print("The Python version is", sys.version)
Copied!

tasks.entrypoint

You can override the Docker image ENTRYPOINT if needed or specify one. Unlike the Docker ENTRYPOINT instruction that has a shell and exec form, the entrypoint attribute only accepts a single string defining the executable to be run.
Example:
1
tasks:
2
- entrypoint: sh -c "Echo $HOME"
Copied!

tasks.env

Sets environment variables to use in the executed task.
When two or more variables are defined with the same name, neuro-flow uses the most specific environment variable. For example, an environment variable defined in a task will override the workflow default.
Example:
1
tasks:
2
- env:
3
ENV1: val1
4
ENV2: val2
Copied!
This attribute also supports dictionaries as values:
1
tasks:
2
env: ${{ {'global_a': 'val-a', 'global_b': 'val-b'} }}
Copied!

tasks.http_auth

Control whether the HTTP port exposed by the tasks requires the Neu.ro Platform authentication for access.
You may want to disable the authentication to allow everybody to access your task's exposed web resource.
By default, tasks have HTTP protection enabled.
Example:
1
tasks:
2
- http_auth: false
Copied!

tasks.http_port

The number of the task's HTTP port that will be exposed globally.
By default, the Neu.ro Platform exposes the task's internal 80 port as an HTTPS-protected resource.
You may want to expose a different local port. Use 0 to disable the feature entirely.
Example:
1
tasks:
2
- http_port: 8080
Copied!

tasks.life_span

The time period after which a task will be automatically killed.
By default, tasks live 1 day. You may want to change this period by customizing the attribute.
The value could be:
  • A float number representing an amount of seconds (3600 for an hour)
  • An expression in the following format: 1d6h15m (1 day, 6 hours, 15 minutes)
Use an arbitrary large value (e.g. 365d) for lifespan-disabling emulation. Keep in mind that this can be dangerous, as a forgotten task will consume cluster resources.
Example:
1
tasks:
2
- life_span: 14d12h
Copied!

tasks.name

Allows you to specify a task's name. This name becomes a part of the task's internal hostname and exposed HTTP URL, and the task can then be controlled by its name through the low-level neuro tool.
The name is completely optional, the neuro-flow tool doesn't require it to work properly.
Example:
1
task:
2
- name: my-name
Copied!

tasks.pass_config

Set this attribute to true if you want to pass the Neu.ro config used to execute neuro-flow run ... command into the spawned task. This can be useful if you use a task image with Neuro CLI installed and want to execute neuro ... commands inside the running task.
By default, the config is not passed.
Example:
1
tasks:
2
- pass_config: true
Copied!

tasks.preset

The preset to execute the task with.

tasks.schedule_timeout

Use this attribute if you want to increase the schedule timeout. This will prevent a task from failing if the Neu.ro cluster is under high load and requested resources are likely to not be available at the moment.
If the Neu.ro cluster has no resources to launch a task immediately, this task is pushed into the waiting queue. If the task is not started yet at the end of the schedule timeout, it will be failed.
The default system-wide schedule timeout is controlled by the cluster administrator and is usually about 5-10 minutes.
The value of this attribute can be:
  • A float number representing an amount of seconds
  • A string in the following format: 1d6h15m45s (1 day, 6 hours, 15 minutes, 45 seconds)
Example:
1
tasks:
2
- schedule_timeout: 1d # don't fail until tomorrow
Copied!

tasks.tags

A list of additional task tags.
Each task is tagged. A task's tags are taken from this attribute and system tags (project:<project-id>, flow:<flow-id>, and task:<task-id>).
Example:
1
task:
2
- tags:
3
- tag-a
4
- tag-b
Copied!
This attribute also supports lists as values:
1
task:
2
tags: ${{ ['tag-a', 'tag-b'] }}
Copied!

tasks.title

A task's title. The title is equal to <task-id> if not overridden.

tasks.volumes

A list of task volumes. You can specify a plain string for the volume reference or use the ${{ volumes.<volume-id>.ref }} expression.
Example:
1
tasks:
2
- volumes:
3
- storage:path/to:/mnt/path/to
4
- ${{ volumes.my_volume.ref }}
Copied!
This attribute also supports lists as values:
1
tasks:
2
volumes: ${{ ['storage:path/to:/mnt/path/to', volumes.my_volume.ref] }}
Copied!

tasks.workdir

A working directory to use inside the task.
This attribute takes precedence if specified. Otherwise, the WORKDIR definition from the image is used.

Attributes for actions calls

The attributes described in this section are only applicable to action calls. An action is a reusable part that can be integrated into a workflow. Refer to the actions reference to learn more about actions.

tasks.action

A URL that selects an action to run. It supports two schemes:
  • workspace: or ws: for action files that are stored locally
  • github: or gh: for actions that are bound to a Github repository
The ws: scheme expects a valid filesystem path to the action file.
The gh: scheme expects the following format: {owner}/{repo}@{tag}. Here, {owner} is the owner of the Github repository, {repo} is the repository's name, and {tag} is the commit tag. Commit tags are used to allow versioning of actions.
Example of the ws: scheme
1
tasks:
2
- action: ws:path/to/file/some-action.yml
Copied!
Example of the gh: scheme
1
tasks:
2
- action: gh:username/[email protected]
Copied!
Expression contexts: This attribute only allows expressions that don't access contexts.

tasks.args

Mapping of values that will be passed to the actions as arguments. This should correspond to inputs defined in the action file.
Example:
1
tasks:
2
- args:
3
param1: value1 # You can pass constant
4
param2: ${{ flow.id }} # Or some expresion value
Copied!
Last modified 4mo ago