deniz.in

Markets

Weather

Loading weather

· via dev.to (home feed)

Microsoft's Azure CLI preview lets developers run Logic Apps Standard workflows locally

Microsoft's public preview of a logicapp extension for the Azure CLI lets developers build, run and test Logic Apps Standard workflows fully locally, backed by a containerized Functions runtime.

Microsoft's Azure CLI preview lets developers run Logic Apps Standard workflows locally

Microsoft has a public preview of a logicapp extension for the Azure CLI that lets developers build, edit, execute and test Logic Apps Standard workflows without leaving their own machine. The news comes via a detailed technical write-up by Mubashir Arham, originally published on FutureStack and syndicated on dev.to, which argues the change is more than a convenience: the pieces that make Logic Apps work — a Functions-based host, connector handling and lifecycle management — can now operate outside an Azure datacenter.

How the extension is put together

According to the article, the extension coordinates three distinct jobs. It scaffolds projects, generating a logicapp.yaml manifest, a host.json file and a folder for each workflow. It manages the runtime lifecycle, spinning up a Docker container that mirrors the Azure Functions host — the article cites the mcr.microsoft.com/azure-functions/python:4 image — with the local source directory mounted in, and with start and stop commands acting as wrappers around ordinary Docker operations carried over the engine's Unix socket or Windows named pipe. And it bridges connectors, resolving each one either to a local emulator such as Azurite or to a real remote endpoint, using the same authentication options as the cloud version: managed identity, service principal or connection strings.

The container listens on the Functions default port, 7071, which the CLI forwards to localhost, and inside it the Logic Apps runtime reaches language workers over gRPC in the same way the cloud architecture does. Calls intended for local emulators are redirected to the host machine through host.docker.internal.

State handling and performance

The Logic Apps Standard runtime is stateful: every workflow instance persists variables, checkpoints and retry context. In the preview, the default state store is a local JSON file per instance, rewritten at each checkpoint. Arham points out that teams running load tests should swap in SQLite, configurable through host.json, because the flat-file store leads to out-of-memory errors and sluggish checkpoint writes under sustained throughput.

The article also benchmarks a local Docker setup on a MacBook M2 against a cloud deployment in East US. In the author's measurements, cold starts came in around 1.8 seconds locally versus 2.5 seconds in Azure; a single HTTP action ranged from 85 ms against a local Azurite emulator up to 250 ms when hitting a remote SaaS endpoint; and baseline memory sat near 130 MiB per instance locally versus 150 MiB in the cloud. These are one author's figures rather than Microsoft's published specifications, but the underlying pattern is intuitive: the connector endpoint dominates latency. Emulated or file-backed connectors are quick, while cloud-only connectors still pay the full network round trip.

Mistakes early adopters make

Arham catalogs common failure modes. Assuming every connector works offline produces ConnectorNotFound crashes; each one needs an explicit emulator mapping or a fallback connection string. Hard-coding Azure credentials in workflow definitions invites leaks into Git, so the article recommends forwarding an az login access token into the container instead. Skipping OpenTelemetry and relying on console logs alone means latency spikes go unobserved.

Why it matters

Until now, teams effectively had to deploy a Logic App to Azure before they could see whether it worked, so every debugging pass meant a deployment. The preview makes that loop a matter of seconds and makes test-driven development realistic for orchestration logic. Because the same manifest drives both the local runtime and deployment, it also curbs the divergence that appears when developers hand-edit JSON in the portal. Local execution incurs no Azure consumption charges beyond remote connector calls, which helps teams gauge what an execution will cost before committing to scale.

The caveat Arham emphasizes is that fast local runs do not guarantee fast production runs: real-world performance depends on Azure-side factors — network layout, scale limits and throttling on managed connectors — that a laptop cannot reproduce. His recommendation is to pair local development with a staged cloud environment rather than treat the CLI as final proof that a workflow is production-ready.

  • #azure
  • #logic-apps
  • #azure-cli
  • #docker
  • #cloud

Related posts