Huawei RealtimeTrigger

Huawei RealtimeTrigger

Certified

Trigger a flow for each message on a Huawei DMS for RocketMQ topic

Registers a push listener on the configured topic and fires one Kestra execution per message. The consumer is cleanly shut down when kill() or stop() is called. For batched interval-based consumption use Trigger.

yaml
type: io.kestra.plugin.huawei.dms.rocketmq.RealtimeTrigger
yaml
id: dms_rocketmq_realtime_trigger
namespace: company.team

tasks:
  - id: log
    type: io.kestra.plugin.core.log.Log
    message: "{{ trigger.body }}"

triggers:
  - id: realtime
    type: io.kestra.plugin.huawei.dms.rocketmq.RealtimeTrigger
    accessKeyId: "{{ secret('HUAWEI_AK') }}"
    secretAccessKey: "{{ secret('HUAWEI_SK') }}"
    nameServerAddr: "dms-instance-id.rocketmq.eu-west-101.myhuaweicloud.com:8100"
    topic: my-topic
    groupId: kestra-realtime-group
Properties

Consumer or producer group ID

Consumer group name for Consume/Trigger tasks; producer group name for Publish tasks.

Name server address

Address of the RocketMQ name server, e.g. dms-host: 8100. For DMS for RocketMQ, copy the name server address from the instance detail page in the Huawei Cloud console.

Topic to publish to or consume from

Access Key (AK) used to authenticate with Huawei Cloud

Huawei Cloud access key used together with secretAccessKey to sign API requests. Required for AK/SK-based authentication; not required when providing a pre-obtained securityToken. Sensitive — always provide via {{ secret('NAME') }}.

Defaultfalse

Specifies whether a trigger is allowed to start a new execution even if a previous run is still in progress.

List of conditions in order to limit the flow trigger.

Definitions

Compares a rendered date (defaults to {{ trigger.date }}) against optional after and before bounds expressed as ISO-8601 datetimes with zone.

You must provide at least one bound; if both are set the date must fall strictly between them. Missing both bounds triggers an evaluation error.

Example

Trigger condition to execute the flow only after the specific date.

yaml
id: schedule_condition_datetimebetween
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute once every 5 minutes after the date 2025-12-31T23:59:59Z"

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "*/5 * * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.DateTimeBetween
        date: "{{ trigger.date }}"
        after: "2025-12-31T23:59:59Z"

Trigger condition to execute the flow between two specific dates.

yaml
id: schedule_condition_datetimebetween
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will be executed once every 5 minutes between the before and after dates"

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "*/5 * * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.DateTimeBetween
        date: "{{ trigger.date }}"
        after: "2025-01-01T00:00:00Z"
        before: "2025-12-31T23:59:59Z"
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.DateTimeBetweenio.kestra.core.models.conditions.types.DateTimeBetweenConditionio.kestra.plugin.core.condition.DateTimeBetweenCondition
afterstring

The date to test must be after this one.

Must be a valid ISO 8601 datetime with the zone identifier (use 'Z' for the default zone identifier).

beforestring

The date to test must be before this one.

Must be a valid ISO 8601 datetime with the zone identifier (use 'Z' for the default zone identifier).

datestring
Default{{ trigger.date }}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

Renders a date (defaults to the trigger timestamp) and checks its day-of-week against the provided dayOfWeek.

Accepts ISO-8601 date/time strings; the comparison uses the rendered timezone.

Example

Trigger condition to execute the flow only on a specific day of the week.

yaml
id: schedule_condition_dayweek
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute only on Mondays at 11:00 am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.DayWeek
        dayOfWeek: "MONDAY"
dayOfWeek*Requiredstring
Possible Values
MONDAYTUESDAYWEDNESDAYTHURSDAYFRIDAYSATURDAYSUNDAY

The day of week.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.DayWeekio.kestra.core.models.conditions.types.DayWeekConditionio.kestra.plugin.core.condition.DayWeekCondition
datestring
Default{{ trigger.date }}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

Renders a date (defaults to the trigger timestamp) and checks whether it matches the requested weekday and position in the month (FIRST, SECOND, THIRD, FOURTH, or LAST).

Useful for patterns like “first Monday” or “last Friday”. Dates must be valid ISO-8601 strings.

Example

Trigger condition to execute the flow only on the first Monday of the month.

yaml
id: schedule_condition_dayweekinmonth
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute only on the first Monday of the month at 11:00 am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.DayWeekInMonth
        dayOfWeek: "MONDAY"
        dayInMonth: FIRST
dayInMonth*Requiredstring
Possible Values
FIRSTLASTSECONDTHIRDFOURTH

Are you looking for the first or the last day in the month?

dayOfWeek*Requiredstring
Possible Values
MONDAYTUESDAYWEDNESDAYTHURSDAYFRIDAYSATURDAYSUNDAY

The day of week.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.DayWeekInMonthio.kestra.plugin.core.condition.DayWeekInMonthConditionio.kestra.core.models.conditions.types.DayWeekInMonthCondition
datestring
Default{{ trigger.date }}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

Passes only when the triggering execution belongs to the given Namespace and Flow ID.

Pair with the Flow trigger to react to a single upstream flow; for broader namespace matching use ExecutionNamespace.

Example

Trigger condition to execute the flow based on execution of another flow.

yaml
id: flow_condition_executionflow
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute when flow `flow_a` of namespace `company.team` enters RUNNING state."

triggers:
  - id: flow_trigger
    type: io.kestra.plugin.core.trigger.Flow
    conditions:
      - type: io.kestra.plugin.core.condition.ExecutionFlow
        flowId: flow_a
        namespace: company.team
    states:
      - RUNNING
flowId*Requiredstring

The Flow ID

namespace*Requiredstring

The Flow Namespace

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.ExecutionFlowio.kestra.plugin.core.condition.ExecutionFlowConditionio.kestra.core.models.conditions.types.ExecutionFlowCondition

Evaluates true only if the execution carries all provided labels. Labels can be declared as a map or list; system-reserved labels are rejected.

Useful for filtering Flow triggers to specific environments, owners, or any custom tagging strategy.

Example

Trigger condition to execute the flow based on execution of another flow(s) with certain execution labels.

yaml
id: flow_condition_executionlabels
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute when flow with specified labels enters FAILED state."

triggers:
  - id: flow_trigger
    type: io.kestra.plugin.core.trigger.Flow
    conditions:
      - type: io.kestra.plugin.core.condition.ExecutionLabels
        labels:
          owner: john.doe
          env: prod
    states:
      - FAILED
labels*Requiredarrayobject

List of labels to match in the execution.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.ExecutionLabelsio.kestra.core.models.conditions.types.ExecutionLabelsConditionio.kestra.plugin.core.condition.ExecutionLabelsCondition

Compares the triggering execution’s namespace against a target string using EQUALS, PREFIX, or SUFFIX. The prefix boolean is a shorthand for comparison: PREFIX.

If no comparison is set, it defaults to strict equality unless prefix is true.

Example

Trigger condition to execute the flow based on execution of another flow(s) belonging to certain namespace.

yaml
id: flow_condition_executionnamespace
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute when any flow within `company.engineering` namespace enters RUNNING state."

triggers:
  - id: flow_trigger
    type: io.kestra.plugin.core.trigger.Flow
    conditions:
      - type: io.kestra.plugin.core.condition.ExecutionNamespace
        namespace: company.engineering
        comparison: PREFIX
    states:
      - RUNNING
namespace*Requiredstring

String against which to match the execution namespace depending on the provided comparison.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.ExecutionNamespaceio.kestra.core.models.conditions.types.ExecutionNamespaceConditionio.kestra.plugin.core.condition.ExecutionNamespaceCondition
comparisonstring
Possible Values
EQUALSPREFIXSUFFIX

Comparison to use when checking if namespace matches. If not provided, it will use EQUALS by default.

prefixbooleanstring
Defaultfalse

Whether to look at the flow namespace by prefix. Shortcut for comparison: PREFIX.

Only used when comparison is not set

Renders the provided boolean expression against the upstream execution outputs exposed under trigger.outputs.

If the execution exposes no outputs the condition is false and the expression is skipped. A rendered result of blank, space-only, or literal false is treated as false.

Example

The upstream flow_a must explicitly define its outputs to be used in the ExecutionOutputs condition.

id: flow_a
namespace: company.team

inputs: 
  - id: user_value
    type: STRING
    defaults: hello

tasks: 
  - id: hello
    type: io.kestra.plugin.core.debug.Return
    format: "{{ inputs.user_value }}"

outputs: 
  - id: flow_a_output
    type: STRING
    value: "{{ outputs.hello.value }}"

The flow_condition_executionoutputs will run whenever flow_a finishes successfully and returns an output matching the value 'hello':

yaml
id: flow_condition_executionoutputs
namespace: company.team

tasks:
  - id: upstream_outputs
    type: io.kestra.plugin.core.log.Log
    message: hello from a downstream flow

triggers:
  - id: condition_on_flow_execution_outputs
    type: io.kestra.plugin.core.trigger.Flow
    states:
      - SUCCESS
    conditions:
      - type: io.kestra.plugin.core.condition.ExecutionOutputs
        expression: "{{ trigger.outputs.flow_a_output == 'hello' }}"
expression*Requiredbooleanstring
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.ExecutionOutputsio.kestra.core.models.conditions.types.ExecutionOutputsConditionio.kestra.plugin.core.condition.ExecutionOutputsCondition

Passes when the triggering execution’s current state is included in in and not present in notIn.

If a list is empty it is ignored, so provide at least one of them to avoid unintentionally matching everything.

Example

Trigger condition to execute the flow based on execution status of another flow(s).

yaml
id: flow_condition_executionstatus
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute when any flow enters FAILED or KILLED state."

triggers:
  - id: flow_trigger
    type: io.kestra.plugin.core.trigger.Flow
    conditions:
      - type: io.kestra.plugin.core.condition.ExecutionStatus
        in:
          - FAILED
          - KILLED
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.ExecutionStatusio.kestra.core.models.conditions.types.ExecutionStatusConditionio.kestra.plugin.core.condition.ExecutionStatusCondition
inarray
SubTypestring
Possible Values
CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that are authorized.

notInarray
SubTypestring
Possible Values
CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that aren't authorized.

Renders a templated expression and treats the result as truthy/falsey to decide whether the condition passes.

Blank strings or the literal false (case-sensitive) evaluate to false; everything else is true. Expressions can reference any flow variables available at evaluation time, so make sure they resolve without errors.

Example

Trigger condition to execute the flow when the expression evaluates to true.

yaml
id: myflow
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: Average value has gone below 10

triggers:
  - id: expression_trigger
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "*/1 * * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.Expression
        expression: "{{ kv('average_value') < 10 }}"
expression*Requiredstring
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.Expressionio.kestra.plugin.core.condition.ExpressionConditionio.kestra.core.models.conditions.types.VariableCondition

Passes if any task run has more than one attempt and its state satisfies in / notIn filters.

Provide in states to avoid matching nothing (an empty in list fails all attempts). Use with Flow triggers to react when retries occur.

Example

Trigger condition when any flow task on retry enters the state specified in the in states under the HasRetryAttempt condition.

yaml
id: flow_condition_hasretryattempt
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute when any flow task on retry enters a specific state(s)."

triggers:
  - id: flow_condition
    type: io.kestra.plugin.core.trigger.Flow
    conditions:
      - type: io.kestra.plugin.core.condition.HasRetryAttempt
        in:
          - FAILED
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.HasRetryAttemptio.kestra.plugin.core.condition.HasRetryAttemptConditionio.kestra.core.models.conditions.types.HasRetryAttemptCondition
inarray
SubTypestring
Possible Values
CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that are authorized.

notInarray
SubTypestring
Possible Values
CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that aren't authorized.

Fails the evaluation if any nested condition is true; otherwise passes.

Combine with other schedule conditions to express “not these dates/states” patterns.

Example

Trigger condition to execute the flow when the condition is not satisfied.

yaml
id: schedule_condition_not
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute on all days except Sunday at 11am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.Not
        conditions:
          - type: io.kestra.plugin.core.condition.DayWeek
            dayOfWeek: "SUNDAY"
conditions*Required
Min items1

The list of conditions to exclude.

If any condition is true, it will prevent the event's execution.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.Notio.kestra.core.models.conditions.types.NotConditionio.kestra.plugin.core.condition.NotCondition

Evaluates nested conditions and succeeds if at least one passes.

Useful for schedule scenarios like “weekends or holidays” without duplicating triggers.

Example

Trigger condition to execute the flow when any of the conditions are satisfied.

yaml
id: schedule_condition_or
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute on Sundays and Mondays at 11am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.Or
        conditions:
          - type: io.kestra.plugin.core.condition.DayWeek
            dayOfWeek: "MONDAY"
          - type: io.kestra.plugin.core.condition.DayWeek
            dayOfWeek: "SUNDAY"
conditions*Required
Min items1

The list of conditions to validate.

If any condition is true, it will allow the event's execution.

type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.Orio.kestra.core.models.conditions.types.OrConditionio.kestra.plugin.core.condition.OrCondition

Uses the Jollyday calendar to check whether a rendered date (defaults to {{ trigger.date }}) is a public holiday for the given country/sub-division.

If country is omitted, the default locale is used. Provide ISO 3166-1 (country) and optionally 3166-2 (region) codes.

Example

Trigger condition to execute the flow only on public holidays.

yaml
id: schedule_condition_public-holiday
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute only on the public holidays of France at 11:00 am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.PublicHoliday
        country: FR

Trigger condition to execute the flow only on work days in France.

yaml
id: schedule-condition-work-days
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute only on the work days of France at 11:00 am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.Not
        conditions:
          - type: io.kestra.plugin.core.condition.PublicHoliday
            country: FR
          - type: io.kestra.plugin.core.condition.Weekend
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.PublicHolidayio.kestra.plugin.core.condition.PublicHolidayConditionio.kestra.core.models.conditions.types.PublicHolidayCondition
countrystring

ISO 3166-1 alpha-2 country code. If not set, it uses the country code from the default locale.

It uses the Jollyday library for public holiday calendar that supports more than 70 countries.

datestring
Default{{ trigger.date}}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

subDivisionstring

ISO 3166-2 country subdivision (e.g., provinces and states) code.

It uses the Jollyday library for public holiday calendar that supports more than 70 countries.

Compares the rendered date/time (defaults to the trigger timestamp) against optional after and before offsets (ISO-8601 times).

Supports ranges that cross midnight (e.g., 22: 00→02: 00). At least one bound is required; missing both raises an evaluation error.

Example

Trigger condition to execute the flow between two specific times.

yaml
id: schedule_condition_timebetween
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute every 5 minutes between 4pm and 8pm."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "*/5 * * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.TimeBetween
        after: "16:00:00+02:00"
        before: "20:00:00+02:00"
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.TimeBetweenio.kestra.plugin.core.condition.TimeBetweenConditionio.kestra.core.models.conditions.types.TimeBetweenCondition
afterstring

The time to test must be after this one.

Must be a valid ISO 8601 time with offset.

beforestring

The time to test must be before this one.

Must be a valid ISO 8601 time with offset.

datestring
Default{{ trigger.date }}

The time to test.

Can be any variable or any valid ISO 8601 time. By default, it will use the trigger date.

Renders a date (defaults to the trigger timestamp) and passes only if it falls on Saturday or Sunday.

Accepts ISO-8601 date/time strings; uses the rendered timezone to determine the day.

Example

Trigger the flow only on weekend, i.e. on Saturdays and Sundays.

yaml
id: schedule_condition_weekend
namespace: company.team

tasks:
  - id: log_message
    type: io.kestra.plugin.core.log.Log
    message: "This flow will execute only on weekends at 11:00 am."

triggers:
  - id: schedule
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 11 * * *"
    conditions:
      - type: io.kestra.plugin.core.condition.Weekend
type*Requiredobject
Possible Values
io.kestra.plugin.core.condition.Weekendio.kestra.plugin.core.condition.WeekendConditionio.kestra.core.models.conditions.types.WeekendCondition
datestring
Default{{ trigger.date }}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

Huawei Cloud Account Domain ID

Identifies the Huawei Cloud account (domain). Required when authenticating against global services such as IAM, or when requesting a domain-scoped IAM token.

DMS instance ID

Huawei Cloud DMS for RocketMQ instance ID. Required when the instance uses instance isolation. Leave empty for shared DMS instances.

Reference (ref) of the pluginDefaults to apply to this trigger.

Huawei Cloud Project ID

Identifies the region-scoped project against which most regional services authenticate. Mutually exclusive with domainId for global services such as IAM.

Huawei Cloud region

Region identifier such as eu-west-101, ap-southeast-1, or cn-north-4.

Secret Key (SK) used to authenticate with Huawei Cloud

Huawei Cloud secret key paired with accessKeyId. Required for AK/SK-based authentication. Sensitive — always provide via {{ secret('NAME') }}.

Pre-obtained Huawei Cloud IAM token used as bearer credential for downstream API calls

When set, downstream Huawei tasks send this value in the X-Auth-Token header instead of signing requests with AK/SK. Sensitive.

DefaultSTRING
Possible Values
STRINGJSON

Message body serializer/deserializer

STRING (default) or JSON.

SubTypestring
Possible Values
CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of execution states after which a trigger should be stopped (a.k.a. disabled).

Default*

Tag filter expression

Server-side filter applied by the broker. Use * (default) to receive all tags, or a specific tag to filter messages.

Inline IAM credential exchange

When set, the connection layer calls the Huawei IAM STS API once per task execution and uses the returned temporary AK/SK + security token instead of the static accessKeyId and secretAccessKey properties.

Configure once via pluginDefaults to apply transparently to every task in a namespace without per-task credential wiring: 

pluginDefaults: 
  - type: io.kestra.plugin.huawei.obs
    values: 
      region: eu-west-101
      temporaryCredentials: 
        authMethod: PASSWORD
        username: my-iam-user
        password: "{{ secret('HUAWEI_IAM_PASSWORD') }}"
        domainName: my-account-domain
        durationSeconds: 3600

**Long-running tasks: ** the exchange runs once at execution start. For RealtimeTrigger or long-running Consume tasks that outlive durationSeconds, credentials will expire mid-run. Use long-lived AK/SK properties or refresh externally in that case.

Definitions
authMethodstring
DefaultPASSWORD
Possible Values
PASSWORDTOKEN

Authentication method

Controls which credentials are used to obtain the session token before exchanging for temporary STS credentials.

  • PASSWORD (default): provide username, password, and domainName.
  • TOKEN: provide an existing iamToken (X-Auth-Token).
domainNamestring

Account domain name (PASSWORD method only)

The Huawei Cloud account name (domain name) that owns the IAM user. Required when authMethod is PASSWORD. Visible in the Huawei Cloud console under My Credentials → Domain Name.

durationSecondsintegerstring
Default900

Lifetime of the temporary credentials in seconds

How long the returned temporary AK/SK/security-token should remain valid. Huawei Cloud accepts values between 900 (15 minutes) and 86400 (24 hours). Defaults to 900 seconds.

endpointSuffixstring
Defaultmyhuaweicloud.com

Huawei Cloud IAM endpoint suffix

Domain suffix used to build the IAM endpoint URL when no explicit endpoint override is set. Defaults to myhuaweicloud.com. Set to myhuaweicloud.eu for the European sovereign cloud (region eu-west-101 / EU-Dublin).

iamTokenstring

IAM token to exchange (TOKEN method only)

An existing Huawei Cloud X-Auth-Token to exchange for temporary STS credentials. Required when authMethod is TOKEN. Sensitive — always provide via {{ secret('NAME') }}.

passwordstring

IAM password (PASSWORD method only)

Password for the IAM user identified by username. Required when authMethod is PASSWORD. Sensitive — always provide via {{ secret('NAME') }}.

projectNamestring

Project name for project-scoped tokens (PASSWORD method only)

Overrides the project name used for scope=PROJECT token requests. Defaults to the task's region value when omitted, which is correct for most regions.

scopestring
DefaultPROJECT
Possible Values
PROJECTDOMAIN

Token scope (PASSWORD method only)

Scope of the session token obtained during password authentication.

  • PROJECT (default): token is scoped to the project matching projectName (or the task's region when projectName is omitted). Use for most downstream tasks.
  • DOMAIN: token is scoped to the domain.
usernamestring

IAM username (PASSWORD method only)

Huawei Cloud IAM username. Required when authMethod is PASSWORD.

Message body, deserialized according to serdeType

Timestamp (milliseconds since epoch) when the message was created on the producer side

Message keys (space-separated on the wire)

Unique message ID assigned by the RocketMQ broker

Message tags used for server-side filtering

Topic the message was published to

More Plugins in this Category

Liquibase
Liquibase

Tasks that run Liquibase change management commands.

Data

2 tasks

OPA (Open Policy Agent)
OPA (Open Policy Agent)
Enterprise

Tasks to manage Open Policy Agent policies and decisions, including upload, evaluation, and partial evaluation.

Infrastructure

5 tasks

3 blueprints