Trigger on Blob and Data Lake arrivals, stream Event Hub and Service Bus messages, call Functions, and kick off Data Factory pipelines and Batch jobs, all from one flow. Chain storage, compute, and messaging into a single execution history instead of wiring Logic Apps, Event Grid subscriptions, and Function bindings between every pair of services.
Azure's Blob Storage, Event Hub, Service Bus, Functions, Batch, and Data Factory each work well alone, but chaining them today usually means a Logic App, an Event Grid subscription, and a Function binding wired one pair at a time. Kestra triggers on a blob arrival or an Event Hub message, calls a Function, publishes to Service Bus, and runs a Data Factory pipeline or a Microsoft Fabric job, all inside one execution history. Provision the underlying resources with Terraform and the whole estate runs from one control plane.
A weekly flow lists a container, copies each blob into a dated archive prefix, and notifies Slack with the count. It then pauses before deleting expired backups so only the destructive step waits on a named reviewer.
The full YAML and topology will appear here once the azure-blob-backup-retention-cutover blueprint is published in the catalog.
Azure ships 41 tasks and 7 triggers across storage, messaging, compute, and Batch, each with its own trigger surface. Kestra wires them into one flow, with one execution history, without Logic Apps connectors, Event Grid subscriptions, or Function bindings between every pair of services.
blob.Trigger and adls.Trigger poll a container on an interval, filter by prefix and regex, and fire once per matched file. The action property moves or deletes processed blobs so the same file never fires twice. No Event Grid subscription or Data Factory storage-event trigger is required just to react to a new file.
eventhubs.RealtimeTrigger starts an event processor that fires one execution per message; eventhubs.Consume polls in batches on a schedule for aggregation and threshold checks. Both checkpoint to Blob Storage automatically, so no separate Stream Analytics job is needed just to track what has already been read.
servicebus.Publish, servicebus.Consume, and the polling and real-time triggers read and write queues and topic subscriptions directly. A message becomes a flow input or output without a Logic App connector translating between the bus and whatever runs next.
function.HttpFunction invokes an Azure Function over HTTP from any Kestra trigger: a webhook, a Kafka message, a dbt completion, a schedule. A Function no longer needs its own Event Grid subscription or Blob-triggered binding to run; it becomes one step in a larger flow instead of an isolated endpoint.
A single flow can move from a blob arrival through a Function transform, a Service Bus publish, and a Data Factory run, with retries scoped to each step and one execution ID covering every hop. Today that same chain usually means a Logic App workflow stitching four services' native triggers together by hand.
monitoring.Query reads a pool's utilization metric, an If task decides whether to scale, and batch.pool.Resize adjusts dedicated and low-priority node counts. blob.DeleteList clears blobs past a retention prefix on the same schedule. Both run as an automated gate, not a person approving a cost dashboard.
Patterns cloud platform teams run in production today. Each one shows the flow end to end, with the real plugin classes in play.
blob.Trigger polls the stage container under a prefix, moves each processed file to an archive path, and fans it out with a ForEach. Files can load into a cross-cloud warehouse, trigger a dbt build, or feed a Data Factory pipeline, all from one arrival event, without an Event Grid rule per destination.
Prefix-based routing lives in the flow, not in a Data Factory linked service per target.
The action property moves processed blobs so the next poll never reprocesses them.
One execution links the blob event, the load, and the transform, across clouds if needed.
A schedule runs eventhubs.Consume every 5 minutes to pull whatever landed in a 30-second window. An If task compares the count against the floor for a healthy producer. Below it, PagerDutyAlert fires with a dedup key, so a stalled producer pages on-call before a downstream job fails on missing data.
Consume checkpoints to Blob Storage, so each window only counts events not yet read.
The PagerDuty dedup key keeps repeated low-volume windows on a single incident.
The volume floor is a flow value, not a hardcoded threshold buried in a Function.
A blob arrival calls function.HttpFunction to validate and reshape the file, publishes the result with servicebus.Publish for any downstream subscriber, then runs datafactory.CreateRun for the heavier processing. Teams gets one notification for the whole chain, not one per service.
Blob, Functions, Service Bus, and Data Factory share one audit trail end to end.
Each hop calls the next service's plugin task directly, no connector translating between them.
A Function timeout retries the Function step only, not the whole chain.
An hourly flow runs monitoring.Query against a Batch pool's utilization metric. An If task decides whether to scale, and batch.pool.Resize sets new dedicated and low-priority counts. The same run purges blobs past a retention prefix with blob.DeleteList, both automated, no dashboard click.
The scale and purge decisions are both an If gate, not an approval step.
Compute scaling and blob retention share the same schedule and execution ID.
targetDedicatedNodes and targetLowPriorityNodes scale independently.
A weekly flow lists a container, copies each blob into a dated archive prefix with blob.Copy, and notifies Slack with the count. The storage account's own GRS or RA-GRS replication handles the actual cross-region copy. The flow then Pauses before deleting expired backups; a named reviewer resumes it, and only then does blob.DeleteList remove them. Deleting a backup is worth a second pair of eyes.
Only the destructive step, deleting expired backups, waits on a human.
The Pause task records who approved the deletion and when.
The copy count, the approval, and the delete all trace to one execution.
| Capability | ||||
|---|---|---|---|---|
| Trigger on Blob/ADLS arrival, Event Hub, or Service Bus message | Native triggers across all three, no glue | Storage event trigger via Event Grid wiring | Eventstream item, Fabric-scoped | Sensors and hooks per source, custom code |
| Chain Functions, Service Bus, and Data Factory in one flow | Native plugin tasks, any order | Web/Webhook activities glue services together | Fabric-centric, limited outside the workspace | Custom operators per service |
| Real-time Event Hub consumption, one execution per message | eventhubs.RealtimeTrigger | Stream Analytics job required | Eventstream item inside the workspace | Kafka sensor plus custom consumer code |
| Cross-service audit trail in one place | One execution ID spans every service | Per-pipeline monitor, Functions and Service Bus separate | Fabric monitoring hub, external services invisible | Per-DAG logs, external calls opaque |
| Automated cost guardrail on compute scaling | Monitor.Query + If + pool.Resize in one flow | Autoscale formulas, no cross-service condition | Fabric capacity is a separate, fixed purchase | Custom sensor plus scaling script |
| Approval gate before a destructive action | Pause + resume, named reviewer logged | Requires a Logic App approval connector | Not native | Custom operator with an external wait |
| Self-hosted, air-gapped, OSS edition | Self-hosted by default, OSS edition free | Azure-managed only | Microsoft-managed only | Self-hosted |
| Vendor lock-in | Azure is one plugin among hundreds; flows stay portable | ADF pipelines are Azure-only | Fabric items are Microsoft-only | Portable, but no managed cloud offering |
Side-by-side breakdown across event triggers, cross-service chaining, Batch cost guardrails, and running off the Azure-managed-only model.
Find answers to your questions right here, and don't hesitate to Contact Us if you couldn't find what you're looking for.
Real-time triggers on Azure Event Hubs and Blob Storage
Step-by-step setup for Kestra's real-time triggers against Azure Event Hubs and Blob Storage, including the console screenshots for creating the namespace and container.
Azure Batch orchestration
How Kestra runs Azure Batch jobs with declarative YAML, triggers, and monitoring, instead of hand-managing pools and job lifecycles.
Azure plugin reference
Every Azure task (Blob, ADLS, Event Hub, Service Bus, Functions, Batch, Data Factory, Cosmos DB, Monitor) with copy-ready YAML and full property reference.
Trigger on Blob and Event Hub arrivals, chain Functions and Service Bus, run Data Factory and Batch jobs, and gate the one step that deserves a human review. Open source, self-hosted, event-driven.
