types: [ready_for_review, opened]

slug: mqtt-triggers

title: MQTT triggers

version: v1.475.0

tags: ['MQTT', 'Triggers']

description: Trigger scripts and flows in response to MQTT broker messages.

features:

[

"Connect to MQTT brokers and trigger runnables in response to published messages.",

"Subscribe to multiple topics with configurable QoS levels.",

"Process messages with basic scripts or use preprocessors for advanced message handling.",

"Access message metadata including topic, QoS level, and MQTT v5 properties.",

"Support for both MQTT v3 and MQTT v5 protocols with configurable options.",

"Automatically generate TypeScript script templates for message processing."

]

docs: /docs/core_concepts/mqtt_triggers

video: https://www.youtube.com/watch?v=T_ava06lqlc

In terms of billing for Windmill [Enterprise Edition](/pricing), Windmill measures how long the workers are online with a minute granularity. If you use 10 workers with 2GB for 1/10th of the month, it will count the same as if you had a single worker for the full month. It's like if in your [Windmill setup](../../misc/7_plans_details/index.mdx#setup-and-compute-units), the replicas of the worker group would adjust for a given amount of time.

Windmill uses Compute Units (CUs) to measure and track resource usage across your EE instances.

A [compute unit](/pricing#compute-units) (CU) represents the computational resources allocated to a worker based on its memory limit. The memory limit determines the size and capacity of the worker, therefore its Compute Units.

Compute Units are calculated as follows:

- A worker with 1GB memory limit = 0.5 CU

- A worker with 2GB memory limit = 1 CU

- A worker with 4GB memory limit = 2 CUs

- On self-hosted plans, any worker with more than 2GB of memory counts as 2 Compute Units (e.g., a worker with 16GB counts as 2 Compute Units)

- On cloud plans, the number of Compute Units scales linearly with memory (e.g., a 4GB worker = 2 Compute Units, 8GB worker = 4 Compute Units)

- 8 native workers count as 1 compute unit. They go 8 by 8. Native workers are workers within the native worker group. This group is pre-configured to listen to native jobs tags (query languages). Those jobs are executed under a special mode with subworkers for increased throughput. You can set the number of native workers to 0.

Based on the telemetry your EE instances send, Compute Units are calculated as follows:

- The memory of each worker of all of the prod instances is aggregated against the global compute unit quota

- Compute Units are allocated freely across workers of different sizes based on needs

- The total number of Compute Units is rounded up to the nearest whole number, as there are no half Compute Units

- It only counts workers of all of the prod instances and exclude the other containers like ui, lsp, multi-player, etc.

You can monitor your Compute Units usage from the [Customer Portal](#windmill-customer-portal).

Below are examples from your setup [docker-compose.yml](https://github.com/windmill-labs/windmill/blob/main/docker-compose.yml) file and their Compute Units.

Calculation: 2 workers × 1 CU each + 1 native worker with NUM_WORKERS=8 = 3 CUs

services:

# Other services (db, server, caddy, etc.) don't count towards CUs

windmill_worker_custom_name:

deploy:

replicas: 2 # 2 workers × 1 CU each = 2 CUs

resources:

limits:

memory: 2048M # 2GB = 1 CU per worker

windmill_worker_native:

deploy:

replicas: 1 # 1 worker with subworkers NUM_WORKERS=8 = 1 CU

resources:

limits:

memory: 2048M

environment:

- WORKER_GROUP=native

- NUM_WORKERS=8

services:

windmill_worker:

deploy:

replicas: 3 # 3 workers × 1 CU each = 3 CUs

resources:

limits:

memory: 2048M # 2GB = 1 CU

windmill_small_worker:

deploy:

replicas: 4 # 4 workers with 1GB memory = 0.5 CUs each = 2 CUs

resources:

limits:

memory: 1024M # 1GB = 0.5 CU

windmill_worker_reports:

deploy:

replicas: 2 # 2 workers × 1 CU each = 2 CUs

resources:

limits:

memory: 2048M # 2GB = 1 CU

environment:

- WORKER_GROUP=reports

windmill_worker_native:

deploy:

replicas: 1 # 1 worker with NUM_WORKERS=8 = 1 CU

resources:

limits:

memory: 2048M

environment:

- WORKER_GROUP=native

- NUM_WORKERS=8

services:

windmill_worker_standard:

deploy:

replicas: 2 # 2 workers × 1 CU each = 2 CUs

resources:

limits:

memory: 2048M # 2GB = 1 CU per worker

windmill_worker_large:

deploy:

replicas: 4 # 4 workers × 3 CUs each = 12 CUs

resources:

limits:

memory: 6144M # 6GB = 3 CUs per worker

windmill_worker_reports:

deploy:

replicas: 1 # 1 worker × 1 CU = 1 CU

resources:

limits:

memory: 2048M # 2GB = 1 CU

windmill_worker_native:

deploy:

replicas: 1 # 1 worker with 8 subworkers (can't be changed) = 1 CU

resources:

limits:

memory: 2048M

environment:

- WORKER_GROUP=native

- NUM_WORKERS=8

services:

windmill_worker_standard:

deploy:

replicas: 2 # 2 workers × 1 CU each = 2 CUs

resources:

limits:

memory: 2048M # 2GB = 1 CU per worker

windmill_worker_large:

deploy:

replicas: 4 # 4 workers × 2 CUs each = 8 CUs

resources:

limits:

memory: 6144M # 6GB but capped at 2 CUs per worker

windmill_worker_reports:

deploy:

replicas: 1 # 1 worker × 1 CU = 1 CU

resources:

limits:

memory: 2048M # 2GB = 1 CU

windmill_worker_native:

deploy:

replicas: 1 # 1 worker with NUM_WORKERS=8 = 1 CU

resources:

limits:

memory: 2048M

environment:

- WORKER_GROUP=native

- NUM_WORKERS=8

{/* Move plans section here for enterprise cloud */}

{tier.id === 'tier-enterprise-cloud' && (

<div className="mt-8">

<RadioGroup value={selected} onChange={setSelected}>

<RadioGroup.Label className="sr-only">Server size</RadioGroup.Label>

<div className="space-y-4 mt-4">

{plans.map((plan) => (

<RadioGroup.Option

key={plan.name}

value={plan}

>

{({ checked, active }) => (

<div className={classNames(

checked ? 'border-transparent' : 'border-gray-300',

active ? 'border-blue-600 ring-2 ring-blue-600' : '',

'relative block cursor-pointer rounded-lg border p-3 shadow-sm focus:outline-none sm:flex sm:justify-between'

)}>

<span className="flex items-center w-full">

<span className="flex flex-col text-sm w-full">

<RadioGroup.Label

as="span"

className="font-medium text-gray-900 dark:text-white"

>

{plan.name}

</RadioGroup.Label>

<RadioGroup.Description

as="span"

className="text-gray-500 dark:text-gray-300"

>

<span className="block sm:inline">{plan.description}</span>

</RadioGroup.Description>

<RadioGroup.Description as="div" className="flex w-full justify-end">

+

<span className="text-sm text-gray-900 font-semibold dark:text-white">

${calculatePrice(plan.price, period.value).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',')}

</span>

<span className="text-sm text-gray-500 dark:text-gray-300">

{period.value === 'annually' ? '/yr' : '/mo'}

</span>

</RadioGroup.Description>

</span>

</span>

<span

className={classNames(

'border',

checked ? 'border-blue-600' : 'border-transparent',

'pointer-events-none absolute -inset-px rounded-lg'

)}

aria-hidden="true"

/>

</div>

)}

</RadioGroup.Option>

))}

</div>

</RadioGroup>

</div>

)}

{/* Add the simulation text here for enterprise plans */}

</Link>{' '}with 2GB of memory limit counts as 1 compute unit. On self-hosted plans, any worker with >2GB of memory counts as 2 compute units (e.g. a worker with 16GB counts as 2 compute units). For detailed information on how your setup translates to compute units, see the{' '}

<Link

to="/docs/misc/plans_details#setup-and-compute-units"

className="text-blue-600 hover:text-blue-800 dark:text-blue-500 dark:hover:text-blue-600"

>

setup and compute units guide

</Link>.

, pricing is based on compute units. A compute unit corresponds to 2 worker-gb-month. For example, a worker with 2GB of memory limit (standard worker) counts as 1 compute unit. A worker with 4GB of memory (large worker) counts as 2 compute units. On self-hosted plans, any worker with memory above 2GB counts as 2 compute units (16GB worker counts as 2 compute units). On cloud EE, it scales linearly with the memory limit. The number of compute units is calculated based on the memory limits set for your workers in production instances. You can set memory limits in docker-compose or Kubernetes manifests to control your compute unit usage. For detailed information on how your setup translates to compute units, see the{' '}

<Link

to="/docs/misc/plans_details#setup-and-compute-units"

className="text-blue-600 hover:text-blue-800 dark:text-blue-500 dark:hover:text-blue-600"

>

setup and compute units guide

</Link>. Each worker can run up to ~26M jobs per month (at 100ms per job).