serverless
338 TopicsWhat’s new in Azure SRE Agent at Microsoft Ignite 2026
At Microsoft Ignite 2026, Azure SRE Agent joins Microsoft Teams as a member of your team, with its own Microsoft Entra agent identity. It also now collaborates with other teams’ agents, investigates across AWS and Google Cloud, and starts work from the Azure Container Apps portal, Azure CLI, Grafana, and connector triggers.318Views0likes0CommentsAzure Functions Canvas (Preview): Build, run, and modernize Function Apps with GitHub Copilot
If you use the GitHub Copilot app or Visual Studio Code, meet the Azure Functions canvas. More and more developers now build with coding agents. The Azure Functions canvas helps you get more from that workflow. It addresses three common problems in Azure Functions development: Use official templates without leaving your workflow. Get the same high-quality Azure Functions templates available in VS Code, directly in the GitHub Copilot app. Start building without switching tools. Agents get there eventually, but slowly. A coding agent can produce an app that runs, but it can take many turns. You also can't always tell whether the result follows best practices. Outdated choices cause incidents. Programming models, hosting plans, and runtime versions that reach end of support can cause outages. So can incorrect code or settings. Canvases are new in the GitHub Copilot app. A canvas runs deterministic tasks quickly, without a round trip through the agent. It also gives you a visual workspace with state that you and the agent share. We're only starting to explore what canvases make possible. Build faster with up-to-date templates The canvas includes 90 starter and scenario templates for Azure Functions and Hosted Skills. They're more than samples: many include Bicep templates that deploy with the Azure Developer CLI (azd). The canvas applies a template directly, so the agent needs fewer turns and less time to give you working code. This is real code in your local work tree. You own the code and can extend it with GitHub Copilot, add it to your repository, and deploy it to Azure. The canvas supports the full development loop: create, run locally, test, and deploy. You can also open your project in VS Code to continue development and debugging. Test your event-driven functions Azure Functions is built for event-driven applications, but testing different triggers isn't always straightforward. The Azure Functions canvas brings event-driven testing into your development workflow. It supports HTTP, Timer, Event Hubs, Service Bus, Storage Queue, Blob, Durable Functions, and Blob triggers with Event Grid. Instead of switching between tools, you can test your functions as you build them, making it easier to develop and validate event-driven applications. Build Hosted Skills with templates and an agent With Hosted Skills, you build event-driven agents in natural language. The canvas includes 14 templates for them. Start from the template that matches your scenario to scaffold quickly, then let the agent continue. Built-in skills help the agent with creation, deployment, and configuration. To build and test a Hosted Skill step by step, see Quickstart: Build and test a hosted skill with the Azure Functions hosted skills canvas. Modernize with confidence On PaaS and serverless platforms, you must regularly review programming models, hosting plans, and supported runtime versions. This is important for security and reliability. Internal data from the Azure Functions team shows that 58% of incidents come from code or configuration issues. These issues are easy to miss. With the canvas, you can quickly find them in local projects and in apps deployed to Azure, and then have the agent fix them. Checks are read-only, and fixes need your approval. The canvas helps you follow current Azure Functions security and runtime best practices, from choosing supported configurations to identifying issues in existing applications. Continue development in VS Code Your project is real code, not a prototype locked inside the canvas. Open it in VS Code to continue development with your familiar tools. The generated project includes configuration and infrastructure files to help you run locally and deploy to Azure. Available in seven languages From day one, the canvas supports seven languages: English, Chinese (Simplified), German, Japanese, Korean, Portuguese (Brazil), and Spanish. Get started Find Azure Functions on Awesome GitHub Copilot, or install it from the marketplace: in the GitHub Copilot app, open Customize > Plugins, select Awesome Copilot, and install Azure Functions. Pro tip: install it directly. Start a new session, then ask: Open Azure Functions canvas. Use it in VS Code (Preview). Canvases are available in VS Code 1.142 and later for local sessions that use the Copilot harness. Install the plugin in the GitHub Copilot app as shown above. Then, in VS Code, enable chat.canvases.enabled, start a new session with the Copilot harness, and ask the agent to open the Azure Functions canvas. For details, see Canvases (Preview). On Home, choose a task: Create, Open, Modernize, or Monitor. You don't need extra tools to open the canvas. To create from a template or deploy, install the Azure Developer CLI (azd). To run locally, install Azure Functions Core Tools 4. Check prerequisites in the canvas shows what you're missing. Give it a try, and tell us what you think.157Views0likes1CommentAzure SQL Query Editor Won't Connect? Start Here
The Azure portal loads fine, you open Query Editor, and then you get "failed to fetch" or a vague connection error. It's tempting to assume the database is down, or to look for "the Query Editor IP" to add to your firewall. Usually, it's neither. Query Editor runs in your browser, so the problem can start on your laptop, your corporate proxy, the SQL firewall, your sign-in, or the database itself. The quickest fix is to work out which of those layers is failing before you change any server rules. How Query Editor actually connects There's no single Microsoft source IP to allowlist. For public connections to the query editor, you need to add your outbound IP address to the server's allowed firewall rules to access your databases. The IP that matters are the one your network presents to the internet, not an Azure address. Private Link changes this. You don't need to add your IP address to the SQL server firewall rules if you have a Private Link connection set up on the server, and you connect to the server from within the private virtual network. In that case, focus on DNS and whether you're really inside the right network. Check port 443 first Starting in March 2026, the Azure SQL query editor uses only TCP port 443. If something on your network blocks that traffic, you'll see messages about local network settings or proxy configuration. A quick test from PowerShell: Test-NetConnection <server-name>.database.windows.net -Port 443 If TcpTestSucceeded is False, the problem is on the client or network side. Keep in mind that opening 443 locally doesn't replace the SQL server firewall or Private Link setup. You still need both. Proxies and TLS inspection Corporate proxies cause more of these failures than people expect. If you see an error about the X-CSRF-Signature header, verify that your computer's clock is set to the right time and time zone, and if you're behind a proxy, make sure that the request header X-CSRF-Signature isn't being modified or dropped. A simple check: try Query Editor from a clean network, such as a phone hotspot. If it works there but not on the corporate network, talk to your network team, not the database team. Authentication and database users Being signed in to the portal doesn't give you access to the database. For Microsoft Entra sign-in, your database must be configured with Microsoft Entra authentication, and you must have a Microsoft Entra user created in the database. If you see "The server is not currently configured to accept this token," the fix is usually a contained user: CREATE USER [user@contoso.com] FROM EXTERNAL PROVIDER; Serverless databases that are paused On serverless databases, the "not currently available" message often just means your serverless database is currently paused. Selecting Continue starts the resume. Wait approximately one minute, refresh the page, and try again. Know the tool's limits Query Editor is built for quick queries, not everything. The query editor has a five-minute timeout for query execution. Also, the query editor doesn't support connecting to the logical server's master database. For either of those cases, use SSMS or VS Code with the MSSQL extension. Trying SSMS from the same machine is also a good diagnostic, because it shows whether the issue is with the browser path or with general connectivity. Symptom to layer: a quick reference What you see Likely layer First thing to try "Failed to fetch" / local network settings message Browser or client network Test-NetConnection on port 443 Works on hotspot, fails on corporate network Proxy / TLS inspection Ask network team to check header handling X-CSRF-Signature error Clock or proxy Fix system time, check proxy Firewall / client IP not allowed error SQL server firewall Add your current outbound IP only Fails from outside VNet with Private Link Private networking Check DNS resolves to the private endpoint "Not configured to accept this token" Authentication Create the contained Entra user "Database not currently available" Serverless pause Wait about a minute and retry One last word on firewall rules Please don't open wide IP ranges just to get Query Editor working. Add the specific outbound IP you need, remove it when you're done, and use Private Link for anything that needs ongoing access. Most Query Editor failures turn out to be network or identity issues, not database problems. Find the layer first and the fix is usually small. Reference: Azure Portal Query Editor - Azure SQL Database | Microsoft LearnPublic preview: OS-level dependency support via containers for Azure Functions Flex Consumption
Your function needs Chromium to generate a PDF. Or GnuPG to encrypt data. Or a native Linux library that isn’t available in the managed execution environment. Until now, an OS-level dependency could require redesigning the application, moving part of the workload to another service, or selecting another hosting option. Today, we’re announcing the public preview of OS-level dependency support via containers on Azure Functions Flex Consumption. With this capability, you can build a Linux container image containing your function application, one supported Functions language worker, application dependencies, and the OS-level software your workload needs. Azure continues to operate the Functions host, trigger integration, routing, and Flex Consumption scaling outside your image. See it in action: Generate PDFs with .NET and Chromium Consider a function that converts HTML into a PDF by using .NET, Puppeteer Sharp, and Chromium. The application needs more than a NuGet package. Puppeteer Sharp needs a compatible browser and the native Linux libraries and fonts required by Chromium. These dependencies aren’t part of the standard managed execution environment. With OS-level dependency support, the application can package those components in its worker image: The .NET isolated function application The .NET isolated Functions worker supplied through the application’s NuGet dependencies Puppeteer Sharp Chromium and its required Linux libraries Fonts and other assets used when rendering the document After the image is deployed to Flex Consumption, an HTTP request invokes the function. Puppeteer Sharp launches the packaged Chromium browser, renders the supplied HTML, and returns the generated PDF. You can explore the complete implementation in the Azure Functions Flex Consumption .NET isolated container sample. A worker-only container model Flex Consumption uses a different container model from other hosting options where the complete Function App runtime is packaged in the customer image. Bring your preferred compatible Linux or language base image to Flex Consumption. As long as the final image satisfies the Flex worker-image contract, you control the base OS, language runtime, application dependencies, and OS-level packages, while Azure provides and maintains the Functions host. Your Flex Consumption container image contains: Your function application One supported Functions language worker Language and application dependencies OS packages, native libraries, browsers, fonts, drivers, executables, and command-line tools required by the application Azure provides and operates: The Azure Functions host and platform components Trigger integration Request and event routing Communication with the language worker Flex Consumption managed scaling This worker-only boundary is important. The feature isn’t arbitrary web-container hosting, and you don’t package or operate the Functions host. You customize the environment in which your function code runs while retaining the Azure-managed Functions programming and scaling model. For broader context on how Azure Functions separates the managed host from the compute that runs your application, see Separating Compute in Azure Functions: Building for scale, efficiency, and reliability. What makes a Flex app registry-backed? A registry-backed Flex app uses the same `Microsoft.Web/sites` resource as a code-package app. The deployment storage type identifies the deployment model: A code-package app uses `properties.functionAppConfig.deployment.storage.type` set to `BlobContainer`. A worker-image app uses the same property set to `Registry`. For a registry-backed app, `deployment.storage.value` contains the fully qualified image reference, and `deployment.storage.authentication` tells Azure how to pull the image. Registry-backed apps omit `functionAppConfig.runtime` because the language runtime and Functions worker are supplied inside the image. properties: { functionAppConfig: { deployment: { storage: { type: 'Registry' value: '<registry>/<repository>:<tag-or-digest>' authentication: { type: '<authentication-type>' } } } // No runtime property for a Registry-backed app. } } Other Function App configuration, including scale and concurrency settings, remains part of the resource and should be preserved when changing the deployment model. See the complete documentation for authentication options, Azure CLI commands, and the complete resource shape. How it works The end-to-end flow is straightforward: Start with the sample Dockerfile for your supported Functions language. Add the OS packages and native dependencies required by your application. Test the source application locally using the normal Functions development experience. Build and scan the linux/amd64 image, then push it to a supported registry. Configure the Flex Consumption app with the fully qualified image reference. Deploy and validate the complete image integration in Azure, then monitor it through logs and Application Insights. For deterministic deployments and rollback, use an immutable image digest for each release. When you need to update the language worker, runtime, base image, OS packages, or application dependencies, rebuild and test the image, push a new version, and update the function app to reference it. Microsoft publishes supported worker artifacts or packages, depending on the language, along with sample Dockerfiles, but doesn’t provide a Flex Consumption base image. You select and maintain the Linux or language base image that meets your application and organizational requirements. When should you use this feature? Use OS-level dependency support when you want the Flex Consumption programming and scaling model but your function requires software that can’t be supplied through the language package manager alone. Examples include: Browser automation with Chromium and Puppeteer PDF generation with Chromium and Puppeteer Sharp Data encryption and signing with GnuPG Image, audio, or video processing with native libraries Database drivers or vendor-provided native SDKs Custom fonts required for document generation Linux executables and command-line tools invoked by application code This capability isn’t intended as a blanket replacement for other Azure Functions hosting options or general container platforms. Choose it when Flex Consumption fits your workload and OS-level dependencies are the missing requirement. Public preview considerations During the preview, keep these considerations in mind: The preview is currently available in East Asia, West Central US and North Europe, and is rolling out to additional Azure regions over the next few weeks. Use only the documented Functions languages and supported language versions. Images must target Linux amd64. Durable Functions isn’t supported. The Azure Service Bus extension (trigger and output bindings) isn’t supported. Availability zone support isn’t available. The preview doesn’t currently provide a supported experience for running the Flex worker container locally. Continue to test the source application locally and validate the complete image integration in Azure. You are responsible for selecting, securing, scanning, patching, rebuilding, testing, and redeploying the base image, language worker, application dependencies, and OS-level dependencies in your image. Preview capabilities and limitations can change. See the complete documentation for the current language versions, configuration procedures, registry authentication options, operational behavior, and known limitations. Get started Start with the sample for your preferred language: .NET isolated container sample Python container sample Node.js container sample Go container sample Read Use OS-level dependencies via containers with Azure Functions Flex Consumption for the complete image contract and deployment guidance. Try the preview with a workload that needs Chromium, GnuPG, a native library, a driver, a font, or another Linux dependency and share what this capability enables for your application!133Views0likes0CommentsAzure SRE Agent brings on-demand, AI-powered operations to your ACA workloads
Today at Microsoft Ignite, we’re introducing on-demand, AI-powered operations help, powered by Azure SRE Agent. Now in preview, this new experience is built right into the Azure Container Apps portal. Developers can start an interactive debugging session directly from any container app and get evidence-backed, actionable insights in minutes. Each session is serverless and on demand: it starts in seconds, stays focused on your question, and ends when you’re done. There’s no agent infrastructure for you to set up, run, or maintain. Azure Container Apps is the first service to bring this experience to customers, and we plan to extend it to more Azure services in the future. Expert answers, right where you work Checking a deployment, reviewing how an app scales, or tracking down an issue usually means piecing together configuration, revisions, deployment history, and metrics from several tools. That takes time and operational expertise that isn’t always on hand. The agent brings that expertise directly into the developer workflow, so teams get answers the moment they need them and can get back to building. You can ask the agent about any aspect of your app. For example: Understand your app: “How is this app configured, and what does it depend on?” Check a deployment: “Did my last deployment change anything that could affect traffic?” Review scaling and performance: “Why is my app scaling out so often?” Spot risks early: “Is anything in this configuration likely to cause problems?” Troubleshoot an issue: “Why did my latest revision fail to start?” How it works Getting started takes a click. From any app in the Azure Container Apps portal, select Debug with SRE Agent and ask your question. The agent already knows which app you’re looking at, so there’s no evidence to gather or context to explain first. Before it reads anything, the agent tells you what it wants to look at and asks for your approval. From there, it works through your app’s configuration, revisions, deployment history, Azure Monitor metrics, and logs from Log Analytics, much like an experienced SRE would. If something is unclear, it asks a focused follow-up question. When it’s done, it walks you through what it found, shows the evidence behind it, and recommends what to do next. Throughout, the agent works with your own Azure identity and sees only what you already have permission to see. Your Azure credentials stay in your browser, and you can review any data before it’s shared with the agent. The agent is read-only, so it never changes your resources and only proposes fixes, and each session runs in an isolated sandbox that’s deleted when the session ends. The sandbox restricts egress and prevents user data from being stored or shared; the only record of the session is a transcript that you can download from the browser after the session has ended. After a session In most cases, you can act on the agent’s recommendation directly in your app. When an issue requires further assistance, the agent can draft a support request from the session for you to review and submit to Azure Support. Sessions give you answers in the moment. To bring that same intelligence to your entire environment, every day, you can deploy Azure SRE Agent right from the session. Once deployed, it builds lasting context and automates the longer-running workflows that keep your apps running. SRE Agent is rolling out in preview in the Azure Container Apps portal. Start a session on any of your apps to see what it can do and let us know how it went with the quick “How was your experience” prompt at the end of each session. Key benefits No setup: Start a session from any container app, with nothing to deploy or configure. Answers in minutes: Get the likely root cause and a recommended fix, backed by evidence from your app. Secure by design: The agent uses your own Azure identity, only sees the data you approve, and never changes your resources. Right where you work: Everything begins and ends in the Azure Container Apps portal, with no switching between tools. Faster time to resolution: Solve common issues on your own without any wait time, and when you need more help, hand off to Azure Support with the context already captured. We have a lot more to show you. Explore all Azure SRE Agent announcements from Ignite 2026 here!79Views0likes0CommentsIntroducing the new Azure Databricks on Microsoft Azure Government, now in Beta
Closing the gap between innovation and compliance For years, public sector leaders have faced a difficult choice: adopt the latest data and AI capabilities or meet the strict security and compliance requirements of their mission. As a result, many agencies and their partners have not had access to the full set of Azure Databricks capabilities available in the global Azure cloud. On Azure Databricks, we believe the public sector should not have to make that trade-off. Today, we're announcing the Beta release of Azure Databricks on Microsoft Azure Government. Agencies and the organizations that serve them can now build on the same modern data foundation available in global Azure, including Unity Catalog, Databricks SQL, and serverless compute. For details on Azure Databricks release types, see Azure Databricks preview releases - Azure Databricks | Microsoft Learn. One platform across global Azure and Azure Government On global Azure, Azure Databricks has already achieved FedRAMP Class D authorization. With this Beta, the same modern platform arrives in Microsoft Azure Government, giving U.S. public sector customers a modern Azure Databricks option in both Azure clouds. Azure Government is Microsoft's dedicated Azure cloud for U.S. government agencies and their partners. It is physically isolated from the global Azure cloud, and screened U.S. persons operate it to meet the compliance requirements of federal, state, local and tribal governments. Choosing between the two comes down to the workload. Azure Databricks is available today for federal civilian agencies, state and local governments, and partners whose workloads fit FedRAMP Class D in global Azure regions. The new Azure Government environment, now open in Beta, is for organizations that need a dedicated government cloud. In both clouds, Azure Databricks is a first-party Azure service. Agencies manage it in the Azure portal, rely on its native integration with Microsoft Entra ID and apply usage toward their existing Azure commitments, so adoption happens within the cloud, contracts and identity systems they already trust. Under the hood, the new environment shares the architecture of Azure Databricks in global Azure and is built to take in the full Databricks platform, with every feature released in global Azure reaching Azure Government through the same ongoing releases. Authorization path FedRAMP Class D (formerly FedRAMP High) and DoD Impact Level 5 (IL5) authorizations for the new Azure Databricks on Azure Government environment are pending. Once they are in place, agencies and defense partners will be able to bring Controlled Unclassified Information (CUI) and mission-critical workloads to the modern Azure Databricks platform. Until then, the Beta environment must not be used to process CUI or any other data regulated by these standards, and General Availability depends on completing the applicable government authorization process. What's available in Beta Beta is the first step toward the full platform, and it already delivers the core capabilities that data teams depend on. It is intended for non-production workloads, and feature availability might differ from the generally available Azure Databricks service. Unified governance across data and AI: Unity Catalog comes to Azure Government for the first time. Teams can control access, trace lineage and audit usage for every data and AI asset from one place: write a policy once, enforce it everywhere and answer who accessed what, when and why. Analytics that scale without the overhead: Databricks SQL provides fast analytics at high concurrency. For each workload, engineers and data scientists pick classic clusters or serverless compute, spending less time sizing and patching infrastructure and more time on the mission. Security controls on from day one: The Compliance Security Profile is enabled by default in every workspace. It adds enhanced security monitoring, automatic cluster updates and a hardened compute image, and it enforces VM instance types that support Azure Virtual Network encryption for hardware-implemented encryption between cluster nodes. Front-end and back-end connections both require Azure Private Link, which keeps all traffic on the Microsoft backbone network. Visibility into usage and cost: Administrators can query system tables for audit logs, billing, compute, jobs and pipelines, ML experiments, query history and storage in one place, so responding to audit requests and managing spend uses tools they already know. Data that stays in government regions: Data residency is always enforced: customer content is stored and processed only in the U.S. government Azure regions US Gov Virginia and US Gov Arizona. Cross-Geo processing does not apply to Azure Government workspaces and cannot be used to process data outside those regions. Take the next step Starting fresh in the new environment During Beta, access is enabled per subscription. Register a dedicated Azure Government subscription that has never been used to create an Azure Databricks workspace. In the Azure Government portal, open that subscription's Preview features, find the Azure Databricks new GovCloud environment feature and register it (this requires permission to register subscription features). Once the status reads Registered, each new workspace created in that subscription lands in the new environment. Plan Beta workloads for non-production and non-CUI scenarios. Moving from the existing Azure Government environment Because the new environment is separate, registering for Beta leaves your existing workspaces, notebooks, data and configurations untouched, and you can evaluate the new environment alongside them. Use a different subscription from the one that hosts your existing workspaces, since a subscription cannot be registered for both environments at the same time. Four areas deserve early attention: Unity Catalog: Begin now so your teams have time to design and roll out unified governance. Serverless compute: Serverless is new to government environments, so open your internal security and compliance review early. Network encryption: Because the Compliance Security Profile is enabled on every workspace, clusters need instance types that support Azure Virtual Network encryption. Align your cluster configurations and Terraform/ARM templates accordingly. Your ATO: Engage your security and authorizing officials now about adding Azure Databricks on Azure Government to your system's Authorization to Operate (ATO). Updating system security plans, data flows and boundary documentation during Beta positions you to run CUI production workloads at General Availability. Getting started To get started, visit Azure Databricks on Microsoft Azure Government. For questions or feedback during Beta, contact your Microsoft account team. Learn More Azure Databricks on Microsoft Azure Government The new Azure Databricks on Azure Government is now in Beta | Databricks Blog Databricks Partners with Microsoft to bring our Data + AI Platform to Azure Government | Databricks Blog112Views0likes0CommentsSeparating Compute in Azure Functions: Building for Scale, efficiency, and reliability.
As customers bring new workloads to Azure Functions, we continue to evolve the runtime to support them securely and at scale. Compute Separation is part of that work. We're revisiting how the host and language workers are deployed and managed to improve efficiency and reliability, and to enable new capabilities while preserving the Functions programming model. When a Functions app needs more capacity, the work you want to scale is its language worker and customer code. In the co-located, out-of-process hosting model, adding that capacity also adds another Functions host, even if the existing host capacity could coordinate more workers. The language worker is already a separate process, but the platform's unit of scale is still the instance that contains both host and worker. Compute Separation changes that unit of scale. The host and the workers run on separately managed compute, allowing the platform to add workers without creating a host for each one. For customers, that opens up more control over the environment running their code, while the platform retains responsibility for the Functions host. Getting there means revisiting assumptions that were convenient when both components lived in the same instance: access to application files, who starts and replaces a process, and even which side opens the connection. One of the most consequential constraints was networking. Existing workers connect to the host, but the platform's networking model requires the remote connection to run in the other direction. This post follows the engineering decisions behind that change, the cold-start and reliability requirements that shaped it, and how we're building and proving the architecture in small end-to-end steps. Preview scope: Everything in this article describes a preview implementation that is still in progress. It is not a released product contract or a migration recommendation. We expect the architecture, behavior, and scope to change as we implement features and validate performance and reliability. Why change the host-worker boundary? The host and the language worker do different jobs. The host connects the app to the platform's control model and implements the runtime-side contract used for worker assignment, readiness, scaling, and reliability actions. It also understands the Functions execution model: it loads trigger and binding extensions, discovers functions, manages listeners, and coordinates invocations. The language worker understands how to load and execute your code in its language runtime. Process isolation already separates these responsibilities into different processes. Compute Separation also separates their compute and lifecycle. Keeping those components together made several things straightforward. The host could start a child process, communicate over localhost, and treat process exit as a direct signal that its worker had stopped. Configuration and application files were available in the same deployment environment. Those conveniences also created dependencies. Scaling the worker repeated the host's resource overhead. A language-specific image carried the host and its dependencies as well as the language runtime. Host maintenance and application image maintenance were coupled. Consider an application that needs native libraries or a particular operating-system dependency. A customer-provided worker image should let you package that environment without also packaging and maintaining the Functions host. You'd own your application, language runtime, dependencies, and image maintenance. The platform would own the host. Custom worker containers are the first customer-facing scenario we're using Compute Separation to enable. The architecture has broader value, though. A host fix shouldn't inherently require rebuilding every language-specific application image. Adding customer execution capacity shouldn't require repeating the full host. Independent release and scaling decisions become possible, subject to protocol compatibility and the capacity of each component. There is a platform-efficiency motivation too. Keeping combined host-and-worker environments warm fragments capacity by language, version, and instance size. A language-independent runtime gives us more options for reusing warm runtime capacity without preparing every combined environment. That is an architectural opportunity, not a measured cold-start improvement or a customer pricing claim. The goal is to preserve the Functions programming model while changing how its components are operated. Functions still execute in language workers, and trigger and binding behavior still needs to hold across the new boundary. Challenge: the worker couldn't initiate the remote connection In the co-located model, the host listens for a connection and the language worker connects to it. Moving the host to another compute instance might suggest replacing a localhost address with a remote endpoint. The platform's network security model rules out that approach. Once separated, worker pods run customer code, so they aren't allowed to open outbound connections to runtime pods. Any connection between the two has to be initiated by the runtime. One option was to change the workers' connection behavior. That would have had a significant compatibility impact across existing worker implementations. It would also have introduced a worker contract tied to the networking needs of this particular hosting model. We wanted to keep those deployment details out of the language workers. We introduced a platform-owned WorkerProxy between the two sides. The runtime opens an authenticated TLS FunctionRpc stream to WorkerProxy. The language worker connects to WorkerProxy over the worker pod's local network, retaining the worker-initiated connection pattern. WorkerProxy bridges the two connections. Each worker pod contains WorkerProxy and a separate container for the language worker and customer code. WorkerProxy provides the transport bridge and worker-side lifecycle contract. It doesn't become a second Functions host, start the customer process, or take ownership of platform placement and pod deletion. For workers that negotiate HTTP streaming, there is also a separate data path: the host forwards HTTP through WorkerProxy's assigned HTTPS origin to the worker's local HTTP endpoint. Requests still pass through the host. On the runtime side, the preview uses a dedicated Functions.Host executable with a client-backed worker composition. The ordinary co-located host retains its server-backed path. We can develop the new topology without making every existing app switch to it. This preserves an important part of worker compatibility, but doesn't eliminate all protocol work. Remote startup also needs configuration, metadata, and extension delivery. Keeping the connection pattern familiar is different from promising that every existing worker version supports the complete new hosting model. Preview limitations and why they exist The networking constraint affects more than the main connection. The FunctionRpc stream isn't the only conversation between a worker and the host. Some extensions add their own communication paths, where code in the worker calls back into components running in the host. In the co-located model, those calls never leave the instance. In the new topology, they become worker-initiated calls to a remote host, which is the direction the networking constraints rule out. WorkerProxy bridges the main stream, but these additional paths are specific to each extension and carry their own protocols and expectations. Supporting them requires changes in both the host and the extensions. Some of that work was more complex than the initial preview's scope and timeline allowed, so the first preview has extension limitations. Service Bus and Durable Functions are the most visible examples. Service Bus message settlement relies on one of these paths: when a function explicitly settles a message, for example to complete or dead-letter it, the worker asks the host-side extension to perform that operation. Durable Functions has a similar dependency. Operations such as starting an orchestration or raising an event go from the worker to APIs that the Durable Functions extension exposes in the host. Neither extension is supported in the first preview, and host and extension work to address these limitations is in progress. Challenge: protecting cold-start performance Cold-start performance was the key performance requirement shaping the design. Separating compute adds networking and coordination to activation. Optimizing steady-state invocation forwarding would not be enough if starting an application became slower. Activation spans networking configuration, specialization of a host instance for the application, initialization of the application container, and linking the worker to the host. Treating all of that as one serial sequence would make each step's latency part of the wait for useful execution. We designed the activation process to overlap independent work while keeping its dependencies explicit. An assignment can arrive before the language worker starts. Other steps really do need to wait: the host must validate initialization before accepting a link, and invocation dispatch must wait for application setup. The requirement is to parallelize preparation without treating partial progress as readiness. The host-side startup path illustrates those distinctions: Assignment configures the worker side. WorkerProxy accepts application and function-group identity, limits, and the HTTP origin when needed. Assignment acceptance doesn't prove that the customer process has initialized. The runtime establishes and validates the link. It connects to WorkerProxy and validates worker initialization, application proof, and delivered host configuration before accepting the link. Application preparation continues. Advertised extensions are prepared before the initialized signal is published. Metadata acquisition and ScriptHost construction and setup follow. The channel becomes eligible for dispatch. The current application-host setup and channel-readiness checks determine when the worker can receive invocations. A successful Link response is therefore an intermediate checkpoint, not permission to send traffic. Platform status publication is another checkpoint, not proof that the entire serving path has converged. Smaller worker images and more reusable warm runtime capacity give us opportunities to improve startup. Neither establishes the result on its own. Cold-start measurements need to cover the full activation path, including scheduling, image availability, networking, specialization, and linking. Application setup without a shared filesystem Activation also exposed a dependency inside the host: it previously had local access to the customer's deployment. A remote host still needs configuration, function metadata, and binding extensions before it can run the app. For host configuration, the compute host advertises the HostConfiguration=1 capability during initialization. A compatible worker returns a typed envelope containing the configuration, and WorkerProxy relays it. The host validates the delivery rather than asking the proxy to interpret the customer's host.json . Malformed configuration fails admission instead of silently becoming defaults. The selected configuration source stays stable across later worker links and child-host restarts. Adding execution capacity must not silently reconfigure an app because another worker connected. Consistency between workers' configuration and function definitions still needs to be validated. Extensions make the boundary more interesting. Customer function code runs in the worker, but host-side binding extensions still run in the host. The preview implementation can receive an advertised extension archive over the connection, validate and extract it, and prepare those assemblies before extension discovery and listener startup. The host can therefore start without a shared customer deployment mount, but it still has application-specific dependencies. Moving files across the connection doesn't add the extension-specific communication paths described earlier or qualify every binding. Those behaviors also have to work across the new boundary. Challenge: preserving reliability without owning the process The co-located host could observe and manage its worker as a child process. With independent compute, the platform owns process creation and replacement. Existing host logic has to participate in that lifecycle through explicit contracts while preserving recovery behavior. A lost connection, for example, is no longer equivalent to a child process exiting. It tells one component that communication stopped; it doesn't prove what the other component is doing. Admission, draining, and replacement need coordinated decisions rather than assumptions based on local process state. That starts with knowing where work can run. The scheduler selects a ready, non-draining worker in the function's group, using a round-robin preference. For HTTP, a full worker is skipped; if all eligible workers are full, admission waits for capacity. A FIFO gate orders invocation attempts, not execution or completion. Listeners need to follow that capacity too. The preview gates supported pull-based listeners on workers for their function group, so the runtime doesn't keep acquiring events with no corresponding worker available. Push-based triggers and shared listeners need different handling. Preserving trigger semantics requires more than a generic worker-selection policy. When is an invocation actually finished? Planned scale-in requires a precise answer. The host closes new admission, withdraws the worker from usable capacity, and drains accepted work before terminating or unlinking the channel. The platform then remains responsible for physically removing the pod. Accepted work includes invocations still buffered or converting input. HTTP adds another case: a worker can send a successful gRPC invocation response while the HTTP response body is still being forwarded to the caller. Removing the worker at that point can truncate a response even though the invocation protocol reported success. The implementation tracks completion through dispatch and, for proxied HTTP, through response forwarding. Worker retirement waits for that lifecycle. This is a useful example of how a familiar operation, stopping a worker, acquires a more explicit contract once its pieces run independently. Unexpected runtime loss follows a separate path. In the current implementation, WorkerProxy enters a sticky removal-requested state and rejects new work, leaving removal and replacement to the platform. It doesn't transparently attach another runtime or replay invocations. Separate compute boundaries also change the failure scenarios we need to test. A worker failure need not require restarting the host, but a runtime failure can affect several workers for the same application. Independent scaling doesn't eliminate shared dependencies. Challenge: carrying platform services across the boundary The host-worker connection now crosses a network and compute boundary. Authenticating the caller, associating a worker with the right application, and handling credentials become explicit parts of the design. The preview implements TLS, runtime caller tokens, and application-key proof during initialization. Those mechanisms are not a claim that the security contract is finished. The implementation documents limitations in certificate identity validation, shared-key authority, and replay protection. Provisioning, network policy, revocation, and cross-application containment remain part of qualification. Managed identity illustrates how platform integration also affects startup. Application code can need an identity token before worker initialization completes. If identity access depended on completed initialization, startup could wait on itself. The preview includes an opt-in Token Service proxy. WorkerProxy carries the worker's local identity request over the existing runtime-initiated stream, and the host forwards it to the host-side Token Service. That path can operate before the customer's worker stream starts. The application gets access to the operation it needs without moving the upstream Token Service credential into the worker-side forwarding contract. Diagnostics and metering need the same attention to ownership. A failure now involves a runtime, a worker pod, and a connection session; logs need to let us distinguish them while preserving the customer logging path. One runtime can dispatch to several workers, so execution measurements need to identify the worker that actually accepted an invocation. The preview records that attribution at dispatch and tracks completion against the selected worker. Binding and extension work can happen before admission, though, so the worker's execution window doesn't cover the whole invocation pipeline. Those records are part of the accounting work, not a final billing definition. Proving the change one end-to-end outcome at a time The initial checkpoint deliberately used one worker and one HTTP request. Even that small scenario crossed platform assignment, the host's outbound link, worker metadata, readiness publication, and both the HTTP and FunctionRpc paths. It gave us a bounded way to exercise the new connections and contracts together. From there, the work expands along several related dimensions: starting an app without a shared deployment mount, executing correctly as worker capacity changes, integrating with platform services, and qualifying the customer experience. These are parallel workstreams with shared contracts, not sequential releases. Figure 3. An explanatory grouping of overlapping engineering workstreams, with dependencies and validation feedback. This is not an availability timeline. Each step needs an observable outcome. Can another worker join without restarting the application host? Can an early identity request complete during startup? Can a worker drain while its HTTP response is still streaming? Can a non-HTTP trigger preserve its binding and execution behavior? These questions cross repository and component boundaries. The host provides components and contracts, while placement, networking, frontend routing, image delivery, language-worker support, and rollout involve other parts of the platform. A merged host change isn't evidence that the whole service path is ready. Small end-to-end scenarios let us test those interactions before broadening coverage. They also let us revise a contract after learning from it, rather than treating a successful connection as proof that startup, execution, and recovery are complete. What remains to prove The next evidence has to cover the full application workload. Cold-start and scale-out measurements need tail latency and image-cache misses, as well as the activation path under normal conditions. Steady-state tests need to quantify network and proxy overhead. Capacity tests need to establish how many workers a runtime can safely coordinate. Compatibility is another qualification task. We need full fidelity with the existing model to ensure applications continue to run with no modifications. What this makes possible The payoff we're working toward is concrete: customers can own the environment running their code without maintaining the Functions host, and the platform can scale and service those components independently. Custom containers are the first scenario, but the value extends beyond packaging. Separate compute gives the host and workers their own CPU and memory resources. A worker that misbehaves is less likely to take resources away from the host or affect the rest of the app, though work assigned to that worker can still fail. We can also allocate capacity to each role independently, rather than adding host overhead whenever we add workers. That gives us room to use resources more efficiently. This separation also gives us a foundation for more advanced deployment options and more flexible scaling. Customer containers can be smaller because they no longer need to include the host and its dependencies. These are opportunities, not capabilities or performance results we can claim for this preview. We've explored this architecture in internal prototypes. It's exciting to see it making its way into the service and opening up new scenarios for customers, starting with custom worker containers. We also plan to extend this model transparently to existing apps, so current customers can benefit without changing how they build and run their apps. We still have work to do to implement the features and validate the performance, but the direction is clear. Separating the host from the worker gives every Functions app a more reliable and efficient foundation, and opens the door to capabilities we couldn't build with both roles sharing the same compute.101Views0likes0CommentsConnector Namespace is generally available:
A connector namespace is one Azure resource that hosts connections, triggers, connector operations, and MCP server configurations. You create a connection once, then use it from Azure Functions, Foundry agents, Azure Container Apps sandboxes, or your own app. Same 1,400+ connectors you know from Logic Apps and Power Platform. This post is the index. The main GA features each get their own deep dive, and I'll link them here as they go live. What's new Feature What you get Deep dive On-behalf-of (OBO) authentication for MCP connectors Set an MCP connector to Per-user authentication and every tool call runs as the signed-in user, not through a shared connection. The namespace creates one connection per user on first use, for any connector that supports OAuth sign-in. An agent that searches SharePoint for an employee sees only the files that employee can open, and the downstream system's audit trail shows the real user. Read the deep dive Custom connectors and custom MCP servers Bring your own APIs and MCP servers into the namespace, next to the managed catalog. Your internal order API or a partner's MCP server gets the same connection management and identity handling as Salesforce or ServiceNow, and your agents call it the same way. Read the deep dive Polling triggers Set a trigger configuration's delivery mode to Polling and your code pulls events from the namespace when it has capacity, instead of the namespace pushing them to a callback endpoint. There's no inbound endpoint to open, and access comes from an access policy on the connection, not a key. A function that processes new SQL orders can sit behind private endpoints and work through a burst at its own pace without flooding the fulfilment system behind it. Azure Functions consumes polling triggers today, through the Connector trigger in public preview. Read the deep dive Bring-your-own server image in Hosted MCP (public preview) Host your custom MCP servers without operational and management burden - just bring the container image, and let the namespace handle deployment, manage underlying compute, server lifecycle, authentication/authorization, scaling, and more. Read the deep dive GA also includes two platform updates: Managed identity end to end. Use an Azure managed identity as the authentication option for connectors that support it, configured the same way in Bicep and in the portal. For those connectors, your deployment pipeline stands up a namespace and its connections with no client secrets to store, rotate, or leak. New public regions. Create namespaces in more Azure regions: [Add region list]. Run your namespace in the same region as your compute and your data, and meet data residency requirements. We'll keep adding regions after GA based on partner and customer demand. What's next GA doesn't cover everything. Here's what's still coming, so you can plan around it: Observability. Diagnostic logs, Azure Monitor usage metrics, and an OpenTelemetry (OTel) export destination with shared correlation IDs for end-to-end tracing. Virtual network (VNet) integration. Inbound Private Link, and outbound VNet integration with customer-controlled DNS and egress. This is what lets connectors reach private and on-premises systems. Get started Portal: connectors.azure.com Documentation: Create a connector namespace Public preview announcement: aka.ms/connector-namespace/blog If you built on the preview, try the GA features and tell me what still keeps you out of production. That list shapes what we build after observability and VNet. File issues and requests at GitHub Issues.Polling triggers in Connector Namespace: let your code pull connector events
What is a polling trigger? A trigger configuration in Connector Namespace ties an event in an external service, such as a new row in a SQL table, a new email or a new file, to a destination. Each trigger configuration has a delivery mode that decides how events get from the namespace to your code. With webhook delivery, the namespace pushes each event to a callback endpoint on your app. With polling delivery, the namespace holds the events for the trigger configuration, and your code connects outbound to retrieve them, processes them, and acknowledges each one when it's done. In Azure Functions you don't even write that loop: the Connector extension runs it and hands your function the events. On the namespace side, a polling trigger configuration gets its own event queue, handles large messages, keeps run history, and protects against duplicate delivery. One distinction is worth calling out early. The delivery mode controls how events travel from the namespace to your function app. It doesn't change how the managed connector detects changes in the source system. In the walkthrough below, the SQL connector still checks the table for new rows; polling only changes the last hop. While polling is only supported out of the box in Azure Functions today, support for polling will be implemented for other partner services based on customer feedback. So, make your voice heard if it is something you want to see on other applications. Why it matters Choosing a delivery mode comes down to four things: latency, processing capacity, networking and authentication. Webhook delivery still wins on latency. Polling is the better fit for the other three. Capability Polling Webhook Event delivery and latency The Functions host retrieves events through outbound requests. Events wait until the host polls. The namespace pushes events as soon as it picks them up from the source. Lower latency. Processing capacity The host takes more events as capacity frees up. Pending events stay queued in the namespace, subject to its retention limits. Events arrive regardless of the app's capacity. Throttled or failed callbacks can lose events once retries run out. Inbound networking No inbound endpoint. Only outbound HTTPS to the namespace polling endpoint. The namespace must be able to reach the app's callback endpoint. Authentication The function app's managed identity, with an access policy on the connection. The Connector extension system key by default, or Microsoft Entra ID with App Service built-in authentication. Your function sets the pace With webhook delivery, events land whenever the source produces them. If your app is at its scale-out limit, callbacks get throttled or fail, and an event that isn't delivered within the service's retry limits can be lost. With polling, the backlog waits in the namespace and the host pulls more work only when it has capacity. Combine your app's scale-out limit with the polling concurrency settings and you have a hard ceiling on how hard your function hits the database or API behind it. No public endpoint Polling doesn't need a public callback URL or a function app system key, because your app retrieves events instead of receiving callbacks. You can put the function app behind private endpoints or inbound access restrictions, and polling keeps working as long as the app can make outbound HTTPS calls to the namespace. Managed identity instead of keys The Functions host authenticates with Microsoft Entra ID. In Azure, that's the function app's system-assigned or user-assigned managed identity. On your machine, it's your developer identity. Either way, access is granted with an access policy on the managed connector connection, so there's no secret to store or rotate. Scale that follows the backlog In polling mode, the Connector trigger uses target-based scaling based on the estimated event backlog for the trigger configuration. The scaling target is independent of batch size and per-instance concurrency, so you can tune throughput and protection separately. What you trade Latency. An event waits in the namespace until the host polls for it. You can shorten the gap with the maxPollingInterval host setting, but if every millisecond counts, webhook is still the right mode. Polling delivery is also at least once: a failed invocation isn't acknowledged, and the event can come back after its lock expires, so make your processing idempotent. Polling at a glance Before the Azure Functions walkthrough, here's the shape of any polling setup. The first two steps happen in Connector Namespace and don't depend on the compute you choose. The last two happen wherever your code runs. Create a polling trigger configuration in your connector namespace. Pick the connector, the event, the connection and the inputs, and set the delivery mode to Polling. From then on, the namespace holds events for that configuration until your code takes them. Grant the consuming identity access with an access policy on the managed connector connection. In Azure that's a managed identity; on your machine it's your developer identity. No keys or secrets change hands. Point your code at the namespace with the polling endpoint and the trigger configuration name. There's no callback URL to register, so the consumer can sit behind private endpoints or inbound access restrictions. Poll, process and acknowledge. Your code retrieves events when it has capacity, processes them and acknowledges each one. An event that isn't acknowledged becomes available again after its lock expires, which is why delivery is at least once. In Azure Functions, the Connector extension takes care of the fourth step: you declare the trigger, and the host runs the polling loop, invokes your function and acknowledges the events. The walkthrough maps onto the same pattern. You create the trigger configuration in Step 2, wire up the polling endpoint in Steps 3 and 6, and grant access in Steps 4 and 7. livery pushes events into your app; polling delivery lets your app pull them. Walkthrough: process new SQL orders with a polling trigger Here's the scenario. You have an Orders table in Azure SQL Database. SQL doesn't call anyone when a row is inserted, and the fulfilment system downstream can only take so many requests at once. You want a function that picks up each new order, without opening an inbound endpoint and without flooding fulfilment when a batch of orders lands at once. Figure: the walkthrough scenario. The numbers match the four steps in Polling at a glance. The walkthrough uses C# with the .NET isolated worker and the Connector Namespace portal. Python and Node.js follow the same steps; the documentation has the code for both. Before you start You need: An Azure subscription and a connector namespace. If you don't have one, create a connector namespace first. An Azure SQL database with an Orders table. The SQL connector's new-item trigger needs an IDENTITY column on the table. A .NET isolated worker Functions project, Azure Functions Core Tools and the Azure CLI. Step 1: Add the Connector extension Add version 1.0.0 or later of the Connector extension package to your project: dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Connector Step 2: Create the polling trigger configuration Go to the Connector Namespace portal and select your namespace. In the namespace menu, select Triggers, and then select Create. Find the SQL Server connector and select the When an item is created (V2) event. Create a connection or select an existing one. Creating a connection takes a one-time authentication with your SQL server. Provide the inputs the event needs: the server, the database and the Orders table. For Destination type, choose Azure Functions. For message delivery method, choose Polling. Review the configuration, and then select Create. Unlike webhook delivery, you don't need the function app deployed before you create the trigger configuration. The function finds the configuration by name. Step 3: Copy the polling endpoint Your function needs the namespace's polling endpoint. Copy it from the trigger configuration in the Connector Namespace portal: Configuration Required Portal Value ConnectorNamespace__PollingEndpoint Base Url configuration %TriggerConfigurationName% Trigger Configuration name Step 4: Grant access to the connection The identity that polls needs an access policy on the managed connector connection. Note that the policy goes on the connection, not on the namespace, and that signing in or turning on a managed identity doesn't grant this access by itself. For local development, the caller is your developer account. For a deployed app, it's the app's managed identity. Use the principal (object) ID, not the application (client) ID. In the Connector Namespace portal, select your namespace and open Connections. Select the SQL Server connection your trigger configuration uses. Open the Access Policies tab and add a policy for the caller identity. Check that the caller now appears in the connection's access policies. Step 5: Write the function The SQL connector doesn't have a strongly typed .NET payload yet, so the function binds to string and receives the raw JSON. Connectors that do have typed payloads, such as Office 365 Outlook, can bind to their payload model instead. using System.Text.Json; using Microsoft.Azure.Functions.Worker; using Microsoft.Azure.Functions.Worker.Extensions.Connector; using Microsoft.Extensions.Logging; namespace Contoso.Products; public class SQLServerOnNewProduct { private readonly ILogger<SQLServerOnNewProduct> _logger; public SQLServerOnNewProduct(ILogger<SQLServerOnNewProduct> logger) { _logger = logger; } [Function(nameof(SQLServerOnNewProduct))] public void Run( [ConnectorTrigger( DeliveryMode = ConnectorTriggerDeliveryMode.Poll, Connection = "ConnectorNamespace", TriggerConfigName = "%ONSQLNewProductTriggerConfigName%")] string payload) { using var document = JsonDocument.Parse(payload); var productName = document.RootElement .GetProperty("body") .GetProperty("Name") .GetString() ?? throw new JsonException("The product name must not be null."); _logger.LogInformation("Received product: {ProductName}.", productName); } } Three properties do the work. DeliveryMode = ConnectorTriggerDeliveryMode.Poll switches the trigger from the default webhook mode to polling. Connection = "ConnectorNamespace" is a settings prefix: the extension reads the polling endpoint from ConnectorNamespace__pollingEndpoint and the identity settings from the same prefix. TriggerConfigName points at the trigger configuration, here through the NewOrderTriggerConfigName app setting so you can change it per environment. Step 6: Run it locally Add the settings to the Values section of local.settings.json : { "IsEncrypted": false, "Values": { "AzureWebJobsStorage": "UseDevelopmentStorage=true", "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated", "ConnectorNamespace__pollingEndpoint": "<my-trigger-base-url>", "ONSQLNewProductTriggerConfigName": "<my-trigger-configuration-name>" } } Leave out ConnectorNamespace__credential locally, and the extension uses your developer credentials. Sign in, start the host, and insert a row: az login func start -- Insert 3 sample products into AdventureWorksLT (SalesLT.Product) -- ProductID is an IDENTITY column; rowguid and ModifiedDate have defaults. INSERT INTO SalesLT.Product (Name, ProductNumber, Color, StandardCost, ListPrice, Size, Weight, ProductCategoryID, SellStartDate) OUTPUT inserted.ProductID, inserted.Name, inserted.ProductNumber, inserted.ListPrice, inserted.ModifiedDate VALUES (N'Polling Trail Bike 42', N'CN-POLL-001', N'Red', 812.50, 1299.99, N'42', 11800.00, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Mountain Bikes'), GETDATE()), (N'Polling Aero Helmet', N'CN-POLL-002', N'Black', 22.75, 49.99, NULL, NULL, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Helmets'), GETDATE()), (N'Polling Water Bottle 750ml', N'CN-POLL-003', N'Blue', 2.10, 6.99, NULL, NULL, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Bottles and Cages'), GETDATE()); Within the next polling cycle, the function logs the new order. Step 7: Deploy with a managed identity In the Azure portal, open your function app, go to Identity, and turn on the system-assigned managed identity. You can assign a user-assigned identity instead. Grant that identity an access policy on the SQL Server connection, as in step 4, using its principal (object) ID. Add the app settings below under Environment variables. Publish the app with func azure functionapp publish <FUNCTION_APP> . App setting Value ConnectorNamespace__pollingEndpoint The polling endpoint from step 3 NewOrderTriggerConfigName new-orders ConnectorNamespace__credential managedidentity ConnectorNamespace__clientId The client ID of the user-assigned identity. Set it only for a user-assigned identity, or set ConnectorNamespace__managedIdentityResourceId instead. Omit both for a system-assigned identity. Because nothing calls into the app, you can now restrict inbound access with private endpoints or access restrictions. Polling only needs outbound HTTPS to the namespace. Step 8: Tune throughput and protect what's downstream The defaults work, but polling gives you levers that webhook doesn't. To take orders in batches, turn on batching and bind to an array of events: [Function("OnNewOrders")] public void OnNewOrders( [ConnectorTrigger( DeliveryMode = ConnectorTriggerDeliveryMode.Poll, Connection = "ConnectorNamespace", TriggerConfigName = "%NewOrderTriggerConfigName%", IsBatched = true, MaxBatchSize = 8, TargetPendingEventThreshold = 16)] ConnectorEvent<string>[] events) { foreach (var orderEvent in events) { logger.LogInformation("Processing event {MessageId}.", orderEvent.MessageId); // Parse orderEvent.Data and hand the order to fulfilment. } } Property Default What it controls IsBatched false Whether each invocation receives a batch of events. Batches are processed one at a time per listener. MaxBatchSize 1 Maximum events per invocation, from 1 through 32. Must be 1 when IsBatched is false. MaxConcurrentCalls 16 Maximum concurrent single-event invocations per listener on one instance. Applies only when IsBatched is false. TargetPendingEventThreshold 16 Desired pending events per instance for target-based scaling. Doesn't change batch size or concurrency. Each property falls back to an app-wide default in host.json when you omit it or set it to 0. The same section holds the polling interval. This example caps the wait between polls at one second when no events are available: { "version": "2.0", "extensions": { "connector": { "maxPollingInterval": "00:00:01" } } } Two more things before you go to production. Delivery is at least once, so make the processing idempotent; for an order, that usually means checking whether you've already sent it to fulfilment. If you deduplicate on ConnectorEvent<T>.MessageId , scope it to the namespace and trigger configuration, because message IDs aren't guaranteed unique across triggers. Feedback Polling is the first delivery mode in Connector Namespace where your code sets the pace, and we want to know how it holds up in your workloads. I'm especially interested in three things: which source systems you're polling, how you're setting batch size and concurrency, and what's missing before you'd run it in production. Tell us in GitHub Issues. For bugs in the Connector extension, open an issue here. To go further: Connector trigger for Azure Functions Connector extension for Azure Functions overview Use managed connectors in Azure Functions Connector Namespace portal Connector Namespace GA announcementWhat's new in Azure Functions durable task scheduler: Durable agents, disaster recovery, and more
There's been a lot happening with the Azure Functions durable task scheduler lately. Here's a quick look at what's new: Durable agents: The Durable Extension for Microsoft Agent Framework is generally available, durable execution with DTS for LangGraph is in preview, and Pydantic AI now includes Azure Durable Task as a built-in durability option. Native disaster recovery and task queues: Both are now in public preview. Private endpoints and customer-managed keys: Both are now generally available. Durable Task Go SDK: Now available in preview. Whether you're running business workflows, processing event-driven pipelines, or coordinating AI agents, here's what these updates mean for your apps and how to get started. What is the Durable Task Scheduler? If you're new to the Durable Task Scheduler, it's a fully managed durable execution backend for workflows and agents on Azure. It saves progress as work runs, so applications can recover from interruptions without starting over. Completed steps whose results have been saved can be reused, and workflows can wait for human input or external events without keeping a worker active just to wait. DTS handles task scheduling, state persistence, and recovery. Its built-in dashboard lets you inspect execution history and manage running orchestrations. The DTS dashboard shows the execution timeline of a travel-planning workflow, including agent calls and a wait for approval. DTS runs separately from your application. Use it with Durable Functions, the Durable Task SDKs, or supported agent framework integrations, including the Durable Extension for Microsoft Agent Framework. Your application code can run anywhere in Azure, including Azure Functions, Azure Container Apps, and Azure Kubernetes Service. Already using DTS? Here's what's new. Durable execution in agent SDKs Agents and workflows need more than conversation history to recover from interruptions. They might call several tools, start a long-running job, or wait for someone's approval. If a worker restarts halfway through, the application needs to know which steps completed and what should happen next. Durable execution saves that progress, so agents and workflows can run for minutes, days, or weeks and resume from recorded progress after worker or container restarts, scaling events, or infrastructure failures. Retry policies help handle transient errors such as rate limits and timeouts. Completed model calls, tool calls, and activities whose results have been saved can be reused during recovery, reducing repeated work and token costs. Conversation context remains available, and workflows can wait for approvals or external events for hours or days without keeping a worker active just to wait. You can bring these durable execution capabilities to agents and workflows built with Microsoft Agent Framework, LangGraph, or Pydantic AI. Here's how to get started with each: Microsoft Agent Framework: The Durable Extension is generally available for .NET and Python. Keep your core agent logic and coordinate durable agents and multi-agent workflows with Durable Task orchestrations or Agent Framework graphs. See the GA blog post and samples. LangGraph: In public preview. Add DTS to existing Python graphs, ReAct agents, and Deep Agents on Azure without rewriting your graph logic. Pydantic AI: Azure Durable Task is now available as a durability capability in Pydantic AI Harness. Use it with Durable Task orchestration and worker setup to persist model and tool results and recover agent execution without building your own checkpointing or recovery system. Native disaster recovery is now in public preview Native disaster recovery for Azure Functions durable task scheduler is now in public preview. For business-critical workflows and applications with cross-region recovery requirements, it provides a way to resume work in another region from replicated state rather than starting workflows over. Pair your primary scheduler with a secondary in another Azure region, and DTS replicates orchestration and entity state to the secondary. When you need to fail over, you can promote the secondary and resume work from that replicated state. Learn more: Disaster recovery documentation. Task queues are now in public preview Task queues for Azure Functions durable task scheduler are now in public preview. Group orchestration and activity work into named queues within a task hub and control how quickly DTS delivers that work to workers. This helps teams pace batch processing and give different workloads their own dispatch-rate budgets without creating separate task hubs. For workloads that call downstream services, it provides a way to manage how quickly work is dispatched. Create a queue, configure its work-item delivery rate, and select it using the DTS_TaskQueue tag when scheduling work. For a closer look at how task queues work and an example of how to use them, see Task queues in Durable Task Scheduler. Learn more: Task queues documentation and SDK examples. Private endpoints are now generally available Private endpoints for Azure Functions durable task scheduler are now generally available for both Consumption and Dedicated SKU schedulers. Connect your applications to DTS through a private IP address in your virtual network using Azure Private Link. Traffic stays on the Microsoft backbone instead of traversing the public internet. You can also disable public network access so your scheduler accepts connections only through private endpoints. Applications continue to use the same scheduler endpoint and Microsoft Entra authentication. Learn more: Configure private endpoints for DTS. Customer-managed keys are now generally available Customer-managed keys for Azure Functions durable task scheduler are now generally available for Dedicated SKU schedulers. Organizations that need to manage their own encryption keys can now use customer-managed keys to protect their workflow data, supporting separation of duties, centralized auditing of key access, and customer-defined key rotation policies. Use a key you own in Azure Key Vault or Azure Managed HSM to protect scheduler data at rest. Configuration is available through the ARM REST API, Azure CLI using az rest, or Bicep. Learn more: Configure customer-managed keys for DTS. The Durable Task Go SDK is now available in preview Writing your application in Go? You can now build durable workflows with the Durable Task Go SDK, available in preview. Write your orchestrations and activities in Go, and let DTS take care of durable state and dispatching work. You can chain activities, run work in parallel, wait for external events, and use durable timers. Retry policies help you handle failures, and orchestration management APIs let you manage execution. Start locally with the DTS emulator, then connect your application to a scheduler in Azure when you're ready. You'll need Go 1.25 or later, and DTS is currently the SDK's only supported runtime. Get started: Go SDK documentation, DTS quickstart sample, and Go sample catalog. Get started with the Durable Task Scheduler If you're new to DTS, start with the documentation and samples. You can develop locally with the emulator, then choose the Consumption or Dedicated SKU based on your workload's pricing and capacity requirements. We'd love to hear your feedback, especially as you try the new previews. Share questions and feedback through the Durable Task Scheduler GitHub repository.98Views0likes0Comments