Weekly Azure Roundup: .NET 11, Durable Agents, and Safer Data
.NET 11 is generally available for C# isolated worker apps in Azure Functions as in-process support ends, requiring project SDK changes and attention to hosting restrictions. The Durable Task extension for Microsoft Agent Framework reaches general availability, preserving execution state outside workers and reusing recorded model results during replay, while Foundry Toolbox guidance separates immutable tool versions from release promotion. Azure Migrate now assesses Container Apps readiness, and Aspire updates add generally available TypeScript apphosts, Kubernetes storage modeling, and dashboard history with development-only security boundaries. Cosmos DB Safe Key Rotation and DocumentDB's generally available service-managed and graceful failovers give teams more control over credentials and regional recovery, though outage failover can lose unreplicated writes. These developments pair broader automation with explicit requirements for validation, authorization, and recovery planning.
This Week's Overview
- Aspire expands application hosting and keeps diagnostic history
- Aspire 13.4 makes TypeScript apphosts generally available
- Aspire 13.5 adds interactive workflows and persistent storage modeling
- Aspire 13.6 preserves dashboard state, with development-only security boundaries
- Multi-repository adoption uses measurable checks
- A distributed-agent example connects application structure to traces
- Azure runtime upgrades require project and hosting changes
- Container Apps connects migration assessment to deployment workflows
- AKS adds node, networking, and policy controls
- AI content processing expands model choice and language coverage
- Microsoft Foundry broadens models and formalizes agent releases
- Claude availability depends on the model and access program
- Kimi K3.1 Pro offers alternative session-management paths
- fal video models roll out in public preview
- Toolbox deployments separate immutable versions from promotion
- Agent Service guidance connects tool selection, identity, and evaluation
- A research-assistant migration preserves contracts and evaluation
- Durable agent workflows keep state and authority outside the model
- Agent-assisted Azure operations add deployment and cost tools
- Azure Monitor adds signed-in agent access and adaptive ingestion limits
- Cosmos DB links safer credentials with repeatable local testing
- DocumentDB adds recovery options and expands application integration
- Service-managed failover handles an unavailable primary region
- Graceful failover preserves committed writes for planned changes
- The MCP Toolkit defaults to read access
- Change Streams broaden capture, with ordering and recovery constraints
- PowerSync brings an alpha offline-first integration
- Migration guidance pairs assessment with operational trade-offs
- Query tuning starts with actual access patterns
- Free tier provisioning becomes faster
- Azure VM infrastructure targets dense compute and confidential workloads
- HDv2 opens preview registration
- AMD confidential VM results show generation-specific gains
- Intel TDX testing highlights storage and networking choices
- Confidential encryption extends to data disks in private preview
- GPU inference comparisons remain workload-specific
- Helios engineering emphasizes rack-wide validation
- Databricks guidance separates data access from identity detection
- PostgreSQL troubleshooting looks beyond query plans
- Azure SQL exposes more operational detail and clarifies architectural limits
- Version-store metrics explain reads hidden by unchanged plans
- Hyperscale distributes responsibilities, not primary writes
- Backup inventory and restore capability answer different questions
- Accelerated recovery trades ongoing work for faster recovery
- Encrypted queries depend on the enclave threat model
- Python parameter binding supports named and positional styles
- SQL MCP auto-configuration needs a security review
- Fuzzy matching addresses imperfect data without a model
- Canadian time zone changes require platform-specific action
- The SQL roundup collects previews and tooling releases
- A Managed Instance report highlights backup-time throughput differences
- Other Azure News
- Also relevant this week
- Dates to know
Aspire expands application hosting and keeps diagnostic history
Aspire's updates cover application composition, deployment, and local diagnostics. The release guidance distinguishes stable capabilities from experimental APIs and integrations that still require preview access.
Aspire 13.4 makes TypeScript apphosts generally available
Aspire 13.4 makes TypeScript apphost generally available, with apphost.mts as the entry point and startup validation running before the application. Resource commands now accept typed arguments with defaults, allowed values, and validation, while WithProcessCommand exposes local scripts and tools. These changes make more development tasks available through the application model rather than separate instructions.
Kubernetes deployment support adds cert-manager, Gateway API, Azure Application Gateway for Containers, arbitrary manifests, and external Helm charts. Go integration moves into the main repository with OpenTelemetry, health checks, module helpers, and Delve debugging. For diagnostics, aspire logs and aspire otel can search server-side before streaming results back.
Aspire 13.5 adds interactive workflows and persistent storage modeling
Aspire 13.5 refreshes the dashboard and adds resource-command file imports, progress dialogs, and interactive terminal sessions. The core Interaction Service and file input APIs are stable, but progress dialogs and terminal APIs remain experimental, and terminal resources require manual debugger attachment.
Kubernetes persistent volume modeling now emits persistent volume claims and StatefulSet workloads using the configured storage class, capacity, and access mode. Existing Azure resources can also be referenced across resource groups, subscriptions, and tenants through literal values or Aspire parameters.
Aspire 13.6 preserves dashboard state, with development-only security boundaries
Aspire 13.6 persists resource snapshots and telemetry in SQLite, retaining up to 10 runs per application with optional pinning. This lets developers inspect earlier runs, but the stored telemetry has no separate encryption or authorization layer. The dashboard remains a development and short-term diagnostics tool, not a protected long-term telemetry store.
Preview interactive database clients require explicit opt-in because they grant full write access. Java and Rust hosting move into first-party preview packages with generated Dockerfiles and debugging through the Aspire VS Code extension. The prerelease Azure sandbox deployment integration requires preview access and currently excludes volumes, TCP ports, private service discovery, and Windows or ARM64 images.
Multi-repository adoption uses measurable checks
The MARS rollout system combines Aspire, Microsoft Agent Framework, and GitHub Copilot SDK in a check, plan, fix, validate, and learn loop. By May 2026, adoption had grown to more than 50 microservice repositories, with the team estimating that agentic onboarding removes 4-8 hours of manual setup per repository.
Repository health comes from deterministic C# metrics, while cloud checks use Azure DevOps pull request and build snapshots. More than 700 end-to-end tests run for every pull request against the rollout system, making validation part of the automation rather than relying on an agent's assessment.
A distributed-agent example connects application structure to traces
AlpineAI brings .NET and Python specialist agents, a Go telemetry generator, a React frontend, and Microsoft Foundry resources into one Aspire AppHost. Its advisor exposes four Agent-to-Agent specialists and a Foundry prompt agent as five tools, with separate hosted chat and .NET WebSocket voice advisors.
Aspire models Azure Container Apps placement, Cosmos DB conversation storage, service dependencies, and health checks. OpenTelemetry traces in the dashboard connect advisor processing to specialist calls, model calls, and downstream HTTP requests.
Azure runtime upgrades require project and hosting changes
The runtime guidance spans an immediate Azure Functions support boundary, upcoming Java deadlines, and a specific Logic Apps migration path. In each case, changing the target framework alone is not enough.
.NET 11 reaches Azure Functions general availability
.NET 11 is generally available for C# isolated worker apps in Azure Functions, while F# support is temporarily unavailable. Projects require Azure.Functions.Sdk 1.0.1 or later, and Microsoft.Azure.Functions.Worker 2.50.0 or later is recommended. The new SDK replaces the build SDK package, not the worker runtime package, and requires changing the project SDK declaration.
In-process model support ended November 10, 2026, and Linux Consumption does not support .NET 10 or later. Container users must account for .NET 11 base images being chiseled images without a shell or SSH server. Non-chiseled and appservice tags are not published.
Java support deadlines call for coordinated upgrades
Azure App Service and Azure Functions support for Java 8, 11, and 17 ends September 1, 2027. Applications will continue running afterward, but those Java versions will no longer receive security updates, improvements, or related customer support. Separately, Microsoft Build of OpenJDK lists September 2027 as the earliest support end for Java 11 and 17, with possible extensions.
The Modernize CLI supports assessment, planning, and upgrade execution, but requires a GitHub Copilot subscription and GitHub CLI. The guide recommends aligning Maven settings, GitHub Actions, and production runtimes, then validating staging deployments and preparing rollback paths.
Logic Apps custom connectors need environment-specific configuration
NuGet-based Logic Apps Standard applications and custom built-in connectors can migrate to .NET 10 while preserving connector registration code and workflow definitions. Prerequisites include .NET SDK 10.0.403 or later and Azure Functions Core Tools 4.16.0 or later, with projects targeting net10.0.
Local development requires FUNCTIONS_WORKER_RUNTIME=dotnet-isolated, while Azure retains dotnet and removes LOGICAPP_INPROC_REDIRECT. Extension bundle configuration must be removed from both host.json and Azure app settings so the packaged runtime registers custom connectors. Validation covered a sample connector action locally and in Azure, not triggers or applications combining NuGet-based and custom-code projects.
Container Apps connects migration assessment to deployment workflows
Azure Container Apps gains an assessment path through Azure Migrate and editor controls for sandboxes. Deployment guidance adds practical boundaries around identity, release management, and model capacity.
Azure Migrate assesses Container Apps readiness
Azure Migrate now includes Azure Container Apps as a target workload for discovered web applications. Assessments report readiness findings, migration requirements, resource recommendations, and estimated hosting costs. Discovery alone does not establish whether an application is ready for Container Apps.
Committing a migration wave accepts the plan but does not start migration. GitHub Copilot app modernization handles the subsequent code changes, validation, containerization, and deployment through workflows for Java and .NET.
AI deployment guidance separates application scale from model capacity
The deployment architecture connects images in Azure Container Registry to Azure Container Apps and Azure OpenAI, using managed identity to reference Azure Key Vault secrets. Increasing Container Apps replicas does not automatically increase Azure OpenAI model capacity, quota, or token throughput, so application scaling and inference capacity need separate planning.
Multiple-revision mode supports traffic splitting, blue-green deployments, and canary releases. For supported deployment pipelines, the guide recommends OpenID Connect workload identity federation instead of long-lived client secrets.
VS Code exposes sandbox lifecycle controls
The Azure Container Apps extension now shows sandbox groups and individual sandboxes in VS Code's Azure Resources view. Developers can create resources, execute commands, create named snapshots, and stop, resume, or delete sandboxes without leaving the editor. Running and Stopped labels show state, while the Azure output channel reports operation results.
AKS adds node, networking, and policy controls
Azure Kubernetes Service updates address workload placement, communication, and enforcement. Several capabilities are generally available, while others remain previews or require explicit configuration.
Azure Container Linux adds provisioning and security inventory
Azure Container Linux now supports AKS node auto-provisioning, which selects virtual machine sizes and provisions nodes according to workload requirements. Confidential VM support covers Intel TDX and AMD SEV-SNP, with FIPS-enabled confidential VM images being introduced. Optional Integrity Policy Enforcement audit mode records execution attempts that violate integrity policies without blocking them.
The CIS Benchmark for Azure Container Linux is generally available. Each image includes an embedded SPDX 2.2 JSON software bill of materials, but vulnerability assessment requires scanners that integrate with that inventory.
Networking updates span fleets and specialized workloads
Cross-cluster networking for Azure Kubernetes Fleet Manager is generally available, covering service discovery, communication, network policy enforcement, and observability across AKS clusters. Multi-NIC pods are in public preview, allowing applications to separate application and storage traffic onto different network interfaces.
Managed DRANET support for remote direct memory access network interfaces is generally available, with topology-aware resource allocation for distributed AI and high-performance computing workloads. Configurable observability dimensions are in public preview for targeted collection during troubleshooting, security investigations, and compliance reviews.
Policy assignments separate auditing from admission enforcement
Azure Policy supports separate enforcement points for Gatekeeper auditing, Gatekeeper admission validation, and Validating Admission Policy. A deny effect scoped only to auditing reports compliance without blocking resources, while Validating Admission Policy runs before Gatekeeper validation when both are selected.
Each assignment can select multiple enforcement points but only one enforcement action. The supplied JSON references undeclared parameters, so it should be treated as an illustration rather than a deployment-ready assignment and definition pair.
AI content processing expands model choice and language coverage
Content Understanding and Azure Speech offer new choices for extracting structured information and transcribing speech. The practical decisions involve measured quality, request configuration, SDK requirements, and regional availability.
Content Understanding supports additional GPT models
Azure Content Understanding adds GPT-5.6, GPT-6, and GPT-6.1 across document, text, speech, and video workflows. In the reported schema-only generally available document extraction evaluations, GPT-6.1 Sol scores 95.74%, compared with Astra's 95.95%, while Astra's completion-token expense is about five times Sol's.
Examples can change the quality comparison: five labeled examples raise Luna's extraction quality from 91.82% to 94.16%. Request-level modelDeployments mappings override resource defaults, letting teams compare models using the same analyzer and inputs rather than changing the extraction setup between tests.
Multilingual speech refinement reaches general availability
Azure Speech multilingual post-stream refinement is generally available, using an LLM Speech streaming model whose final results typically arrive in around 100 milliseconds. Multilingual coverage grows from 29 to 61 locales, and phrase lists support up to 200 phrases and 3,200 characters. Existing integrations receive the engine without code changes, but multilingual post-stream refinement requires Speech SDK 1.50 or later.
Availability covers Central India, East US, North Europe, Southeast Asia, West US, and West US 2. Monolingual post-stream refinement expands from 29 to 148 locales while retaining its parallel second-pass recognition architecture.
Microsoft Foundry broadens models and formalizes agent releases
Foundry's model additions come with different hosting, access, pricing, and retention terms. Agent guidance complements those choices with explicit deployment promotion, delegated authorization, and evaluation practices.
Claude availability depends on the model and access program
Claude Fable 5.2 and Fable 5.2 Fast are generally available, hosted on Anthropic with Global Standard and US DataZone deployment options. Fable 5.2 costs $8 per million input tokens and $40 per million output tokens, while Fast doubles those prices and has no batch pricing. Mythos 5.2 remains restricted to authorized customers through Anthropic verification programs, with eligibility confirmed through Microsoft account teams.
Blocked cybersecurity queries receive responses from Opus 4.8, and blocked biology queries receive responses from Opus 5. Both models require safety-monitoring data retention, although eligible customers can use Fable 5.2 with zero retention until Enterprise Frontier Safeguards becomes available.
Kimi K3.1 Pro offers alternative session-management paths
Kimi K3.1 Pro arrives through Fireworks with 2.8 trillion total parameters and a one-million-token context window. Fireworks provides optimized inference infrastructure, while Foundry handles enterprise deployment and governance. Global Standard pricing per million tokens is $2.05 for uncached input, $0.20 for cached input, and $10.35 for output.
Applications can use Chat Completions, Foundry Responses, or Fireworks Responses direct passthrough. The Responses choice determines where sessions are managed: in Foundry for Foundry Responses, or in Fireworks for direct passthrough.
fal video models roll out in public preview
Five fal-powered video models are rolling out as a first-party Azure service in Foundry: Kling v3 Pro, LTX-2.5 Fast, LTX-2.5 Pro, MiniMax H3 Max, and MiniMax H3 Max Turbo. The initial portfolio is US-hosted, with Foundry described as the first provider of a US-hosted Kling 3 endpoint. LTX-2.5 Fast prioritizes iteration speed, while LTX-2.5 Pro prioritizes output fidelity, and both support synchronized audio.
The announcement contains conflicting pricing units: its tables use video seconds, while introductory text refers to USD per minute. Teams should resolve that discrepancy before using the published figures for cost estimates.
Toolbox deployments separate immutable versions from promotion
A Foundry Toolbox is a versioned collection of tools exposed through one Model Context Protocol (MCP) endpoint within a Foundry Project. Versions are immutable configuration snapshots, later versions require explicit promotion, and rollback means promoting a retained earlier version.
Deployment requires an existing project, project-level role-based access control, and the required connections, along with Azure Developer CLI 1.37.0 or later and the unified microsoft.foundry extension. The sample promotes immediately through a postdeploy hook, but production releases should validate candidates before promotion.
Agent Service guidance connects tool selection, identity, and evaluation
Foundry tool search retrieves relevant tools instead of including every tool definition in each model request. Evaluation datasets can come from sampled traces or be synthesized from instructions, prompts, or reference documents, while insights, rubric evaluators, custom evaluators, and managed memory remain in preview.
User delegation supports On-Behalf-Of access so downstream services can authorize requests using the user's identity. AI Gateway supplies token-rate limits and total token quotas, not native dollar-budget enforcement in Agent Service.
A research-assistant migration preserves contracts and evaluation
A medical research assistant moved from custom infrastructure using Container Apps, PostgreSQL conversation storage, and dynamic sessions toward Foundry hosted agents. Hosted agents provide VM-isolated session sandboxes and manage compute, persistence, scaling, endpoints, and agent identity.
The networking guidance recommends a /24 subnet for production and documents /27 as the supported minimum for smaller deployments. Stable backend contracts let the team retain its evaluation set and expert-supplied golden answers, while traces continued flowing to both Azure Monitor Application Insights and Langfuse.
Durable agent workflows keep state and authority outside the model
The agent engineering guidance separates model reasoning from durable execution and application-owned decisions. That separation matters both when a worker restarts and when an agent proposes a consequential action.
Durable Task support reaches general availability
The Durable Task extension for Microsoft Agent Framework is generally available, storing session and execution state outside the worker process. During replay, completed agent calls with recorded results reuse those results instead of calling the model again. Workflows can also wait for external approval events without keeping a worker active.
Applications must persist their lightweight session references and use the same Durable Task backend across requests. C# and Python applications can run on Azure Functions or self-host, with execution visibility through the Durable Task Scheduler dashboard.
A scheduling implementation gives application code the final decision
The scheduling system lets agents propose placements while application code owns calendar state and validates demand, duration, spacing, conflicts, and capacity. Its Node.js backend runs on Azure Container Apps, with PostgreSQL queues and checkpoints and an Azure Files session workspace.
The gateway persists commands before returning 202 Accepted, and queued replies reach browsers through Server-Sent Events. Shared batches run before up to four concurrent team lanes, while whole-grid evaluation targets failing programs for up to three retries and records model requests and tool calls through OpenTelemetry and Application Insights.
Accountable-agent architecture treats uncertain outcomes explicitly
An illustrative architecture separates experience and reasoning, trusted action, and operational intelligence into three logical planes. Models propose actions, but trusted services enforce authorization, policy, and authoritative state before changing records, with Microsoft Fabric outside booking, payment, and command execution.
Unknown partner outcomes require reconciliation before retries because duplicate detection alone cannot resolve an uncertain booking. The pattern is not a verified production reference architecture and recommends progressing through shadow mode, assisted booking, and bounded autonomy.
Agent-assisted Azure operations add deployment and cost tools
Azure Resource Manager and FinOps tooling expand what agents can inspect and help operate. Their access boundaries differ: the Resource Manager server includes mutation paths, while the FinOps toolkit's Azure MCP server is read-only and scoped to Data Explorer.
Resource Manager MCP adds deployment execution and current-state inspection
The Azure Resource Manager MCP server supports resource and resource-group create/update operations through ARM PUT patterns, plus provider-defined POST actions through execute_resource_action. Deployment tools cover WhatIf previews, execution, status tracking, and cancellation, with Bicep MCP available for authoring and compilation.
The get_resource tool retrieves current ARM state for a resource ID, including tracked, proxy, and extension resources. Cost tools cover general and AKS queries, retail prices, and negotiated price-sheet downloads. Experimental skills return SKILL.md workflows and require the request header x-mcp-toolset: Skills.
FinOps toolkit 15 includes agents and data corrections
FinOps toolkit 15 adds a plugin with five agents and a read-only Azure MCP server scoped to Data Explorer. Local FinOps hubs require Docker with at least 16 GB of container memory, PowerShell 7, and FOCUS cost exports in Parquet format. Private deployments gain optional NAT Gateway support alongside VNet and public networking modes.
FinOps hubs 15 corrects swapped commitment discount eligibility columns, but historical Prices data must be reingested to apply the fix. Azure Optimization Engine now uses a Data Collection Rule and Ingestion API following the Data Collection API's September 2026 deprecation.
Azure Monitor adds signed-in agent access and adaptive ingestion limits
Azure Monitor updates cover how teams inspect telemetry and how workspaces accommodate changing ingestion demand. Existing user permissions govern the agent endpoint, while workspace quota automation requires explicit opt-in.
Grafana MCP uses the caller's existing permissions
The global Azure Monitor dashboards with Grafana MCP endpoint needs no Azure Managed Grafana resource, MCP server deployment, or Grafana data source configuration. It provides 21 tools across five groups, with 20 read-only tools and one for updating existing saved dashboards. Every call uses the signed-in user's Microsoft Entra ID token and existing permissions.
Dashboard updates support validation without saving and version checks that prevent overwriting intervening edits. The endpoint supports user sign-in only and cannot create dashboards or access Grafana alerting, Loki, SQL, or ClickHouse tools.
Workspace ingestion limits can scale with utilization
In public preview, Auto-scale adjusts Azure Monitor workspace ingestion limits upward and downward according to utilization. It is enabled per workspace through an ARM resource update using API version 2026-09-03-preview, and disabling it leaves limits fixed and manually managed.
Changes appear in the workspace Activity Log and can trigger Activity Log alerts. Auto-scale changes the quota ceiling, not the billing basis, which remains the amount of data actually ingested.
Cosmos DB links safer credentials with repeatable local testing
Azure Cosmos DB updates cover account security, local development, and data integration. The emulator examples make testing more repeatable while explicitly separating local evidence from production authentication, capacity, and resiliency checks.
Safe Key Rotation reaches general availability
Safe Key Rotation is generally available and can be enabled from the Azure portal's Features blade. Cosmos DB exposes the last usage timestamp for each account key, allowing teams to check usage before regenerating keys or disabling local authentication.
The accompanying access-control guidance distinguishes Azure control-plane roles from Cosmos DB for NoSQL data-plane roles. Owner and Contributor do not automatically grant item access, and applications that must write without deleting need a custom data role because Built-in Data Contributor includes delete permission. Account keys can bypass scoped data permissions while key-based authentication remains enabled, so dependencies should be migrated and tested before local authentication is disabled.
- Announcing GA of Safe Key Rotation in Azure Cosmos DB
- My Team Is Growing, How Do I Structure Who Gets Access to What?
The vNext emulator and shell improve local diagnostics
The generally available vNext emulator supports Windows, macOS, and Linux hosts on x64 and ARM64 through a Linux container. Scripts mounted at /init run on first startup when ENABLE_INIT_DATA=true, not before every test. OpenTelemetry Protocol export and shell --otel correlate client and gateway spans, while October releases added CosmosBinary, stricter indexing-metadata validation, and an experimental Nacelle gateway.
The shell walkthrough uses version 1.1.280-preview, with .NET SDK 10.0 or later required for global-tool installation and no separate .NET installation needed for self-contained binaries. Its print command performs a point read using the item ID and complete partition key. Authentication is not enforced in the emulator, so successful local operations do not establish production security or performance.
Isolated CI jobs test agent behavior and persisted data
The agentic CI/CD sample gives each coding task a separate Git worktree, owned emulator, versioned fixtures, and task-specific artifacts. Its isolation proof checks independent writes with identical document identities and verifies that removing one emulator leaves the other readable. An observed GitHub Actions run completed three genuine Copilot tasks and passed 75 combined tests, using GITHUB_TOKEN rather than a stored personal access token.
FleetCharge takes a complementary approach with independent component and live-model jobs, each using a fresh emulator. Its live tests make 20 real inference calls and verify persisted recommendation creation, replacement, and deletion, but branch protection or repository rules must require both jobs to enforce the merge gate. Emulator containers do not sandbox untrusted agents, and these tests do not replace live Azure validation.
- Agentic CI/CD with Azure Cosmos DB: Isolated Environments for a Swarm of AI Agents
- From Local Development to CI Workflows with the Azure Cosmos DB Emulator
Confluent connector setup moves into the Azure portal
The native portal experience builds on the existing fully managed V2 Kafka connector for Cosmos DB. Send to Confluent streams Cosmos DB changes to Kafka, while Receive from Confluent writes Kafka records into Cosmos DB, with discovery, resource selection, validation, and cluster creation available from the account.
Setup requires the relevant Confluent cluster and topic, Cosmos DB database and container, and permissions in both services. Confluent organizations provisioned through Azure Native Integrations use Microsoft Entra ID single sign-on and Azure invoice billing.
DocumentDB adds recovery options and expands application integration
Azure DocumentDB's updates distinguish automatic outage recovery from planned, zero-data-loss promotion. Additional tooling covers agent access, change capture, offline applications, migration, and query tuning.
Service-managed failover handles an unavailable primary region
Service-Managed Failover is generally available across Azure regions that support DocumentDB. It promotes a replica when the primary region is unavailable and local recovery across zones is impossible. The feature is disabled by default and requires cross-region replication, a support ticket for enablement, and the global read-write connection string.
Committed writes that have not replicated may be lost during this failover. The guidance recommends combining in-region high availability with service-managed failover for production workloads rather than treating regional replication as a replacement for local availability.
Graceful failover preserves committed writes for planned changes
Graceful Failover is generally available and drains the replication queue before promoting the replica, ensuring every committed primary write has replicated before the switch. The former primary becomes read-only, replication reverses direction, and the global read-write connection string points to the promoted cluster.
This path requires configured cross-region replication and a reachable primary, so it is not suitable when an outage makes that primary unreachable. Users can initiate it through the Azure Portal or management API without application changes beyond adopting the global connection string.
The MCP Toolkit defaults to read access
The open-source Azure DocumentDB MCP Toolkit is in public preview, exposing database operations to AI agents. Read tools are enabled by default, while write and management tools require explicit environment flags. Administrator-defined connection profiles support Microsoft Entra ID, hostname allow lists, and SCRAM-SHA-256 for local or non-Entra setups.
Vector search and BM25 full-text search run through the aggregate tool. The toolkit can run through npx and supports Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot.
Change Streams broaden capture, with ordering and recovery constraints
Multi-Node Change Streams enter public preview, extending change capture beyond single-shard clusters while preserving the watch() programming model. Update descriptions identify changed fields, and optional pre-images expose earlier document values at additional storage and processing cost. Historical Change Streams support replay, with point-in-time-restore integration extending recovery to roughly the last month.
For multi-node consumers, ordering is guaranteed per shard key rather than globally. Topology transitions affect resumability, and failover reinitializes cursors, so consumers need to account for those boundaries.
PowerSync brings an alpha offline-first integration
PowerSync support for managed Azure DocumentDB is an alpha release, using Change Streams to synchronize relevant cloud data into local SQLite databases. Client writes pass through the PowerSync upload queue and application backend before reaching DocumentDB, and synchronized data can be scoped by user, device, tenant, or application context. Evaluations should cover DocumentDB-specific Change Streams, collection operations, document size, and replication behavior because support and behavior remain subject to change.
Migration guidance pairs assessment with operational trade-offs
Azure Migrate's MongoDB assessment experience is in public preview, providing readiness findings, target recommendations, and estimated monthly costs. The DocumentDB Migration Extension uses Azure Database Migration Service, while online migration requires change streams, sufficient oplog capacity, and a coordinated cutover after outstanding changes synchronize. Guidance recommends recording time-to-live index definitions, removing those indexes before migration, and recreating them after final validation.
A separate enterprise case reports migrating 47 TB and more than 7,000 collections, with production cutover completed in under 48 hours. The team disabled high availability and cross-region replicas during ingestion, built non-unique indexes afterward with change data capture synchronization paused, and manually monitored and throttled four balanced migration jobs. Those operating choices are part of the reported result, not a general migration-time guarantee.
- Modernize MongoDB applications with Azure DocumentDB: From assessment to what’s next
- How a Large Enterprise Migrated 47 TB and 7,000+ Collections to Azure DocumentDB in Under 48 Hours
Query tuning starts with actual access patterns
DocumentDB diagnostic logs can route to Log Analytics, where Kusto Query Language identifies slow operations in VCoreMongoRequests. In the example, a single-field index examines 249,800 keys and still requires an in-memory sort, while a compound index on customerId, status, and descending createdAt examines 18 keys for 18 returned documents and removes that sort. An index-covered projection removes the FETCH stage, but every additional index consumes storage and affects writes.
Free tier provisioning becomes faster
Free tier clusters now provision in seconds rather than a few minutes, supporting functional tests and ephemeral agent workflows without changing existing feature compatibility. Admin usernames are now predetermined and can be retrieved through the portal's Connection strings blade, management API, or CLI.
Azure VM infrastructure targets dense compute and confidential workloads
Azure's infrastructure announcements combine new preview capacity with workload-specific performance reports. The benchmark articles consistently require care when comparing configurations or generalizing results.
HDv2 opens preview registration
Azure HDv2 preview registration is open for AI data preparation, compute-intensive high-performance computing, and dense agentic sandboxes. The announcement specifies AMD EPYC 9006 processors with more than 500 physical Zen 6 cores, 3.8 TB of DDR5-8800 memory, 30 TB of PCIe Gen 5 NVMe storage, and 400 Gb Azure Boost Networking.
Microsoft reports approximately twice as many parallel sandboxes and up to 1.7 times the agentic task throughput of its stated next-best in-market alternative. These comparisons are preliminary and subject to change, and the throughput estimate uses SPEC CPU 2026 Integer Rate as a proxy rather than establishing performance for every agent workload.
AMD confidential VM results show generation-specific gains
Reported DCas_v6 results improve on DCas_v5 by 77% in AMD STREAM memory bandwidth, 34% in Redis throughput, and 30% in SPEC CPU 2017. Internal DCas_v7 testing shows 12%-56% higher performance than DCas_v6 across 22 throughput and score results, using Linux and Windows guests at 8 and 32 vCPUs with SEV-SNP enabled.
Fifth-generation AMD EPYC confidential VMs remain in gated preview. The results describe the tested workloads and do not establish a universal confidentiality overhead.
Intel TDX testing highlights storage and networking choices
Intel's matched 16-vCPU, 64-GB tests compare DCeds_v6 confidential VMs with Dds_v6 general-purpose VMs. Confidential VMs retain 97%-99% of SPEC CPU performance, 97% for NGINX-WordPress, and 86% for PostgreSQL-HammerDB in those tests.
Local NVMe delivers nearly five times the IOPS of the single-thread virtualized-SCSI baseline, while MANA networking reaches general-purpose throughput parity at 32 threads. Accelerated Networking through MANA remains in preview for the discussed Intel TDX configuration.
Confidential encryption extends to data disks in private preview
Confidential Data Disk Encryption runs inside the confidential guest, using LUKS2 on Linux or BitLocker on Windows. Secure Key Release checks authorization and attestation claims before releasing key material, and data disks require a separate Disk Encryption Set from confidential OS disks because the key policies differ. Evaluation requires subscription and region enablement through a Microsoft account team.
GPU inference comparisons remain workload-specific
ND GB200 v6 testing covers 264 matched comparisons against bare metal using four GPUs per node, with workloads including DeepSeek-R1-0528, GPT-OSS-120B, and Kimi-K2.5. ND GB300 v6 testing covers 91 matched DeepSeek-R1-0528 configurations and reports throughput, decode speed, and end-to-end latency close to the published InferenceX reference. Because the environments differ, individual gains should not be attributed to virtualization alone.
Helios engineering emphasizes rack-wide validation
Each Azure ND MI455X v7 compute rack contains 72 MI455X GPUs, 18 AMD EPYC Venice CPUs, and 31 TB of HBM4 memory, with a Microsoft-owned two-tier Ethernet backend connecting racks. Microsoft validates firmware, operating-system images, drivers, and diagnostics as a versioned baseline, using SuperBench burn-in and RCCL communication tests to expose failures before nodes enter service.
The Azure and AMD event overview also describes dedicated MI300X capacity through Microsoft Foundry Managed Compute, with private endpoints, managed model-serving software, and GPU-hour billing. Its preproduction data-preparation results remain workload- and configuration-dependent.
- From Silicon to Service: Bringing AMD Helios™ to Azure
- Visit Azure and AMD at Microsoft Ignite and SC26
Databricks guidance separates data access from identity detection
Azure Databricks coverage addresses shared storage configuration and credential-abuse investigation. Both depend on permissions and evidence outside the workspace alone.
OneLake storage has different lifecycle status on each platform
OneLake external-location support for Azure Databricks Unity Catalog is generally available in Microsoft Fabric but remains in preview on Azure Databricks. Setup requires a capacity-backed Fabric workspace, an Azure Databricks Storage item, and an approved managed identity or service principal.
OneLake Security is enabled by default for these storage items, and workspace roles do not grant access to their data. The approved Databricks identity must be the only member of the item's ReadWrite OneLake security role. Fabric users query shared data through mirrored Databricks catalog items without copying it, while Unity Catalog controls access.
Credential investigations need Entra ID and account-level evidence
The detection model correlates event sequences, deviations from identity history, and short-window volume thresholds rather than treating isolated audit events as sufficient evidence. Its example joins Microsoft Entra ID risk detections with Databricks token logins within a one-hour window on either side, requiring IdentityRiskEvent.Read.All and an Entra ID P1 or P2 license.
Verbose logging is not enabled by default, and function_info is masked for users who are not account admins. Workspace Azure Monitor diagnostic settings also omit account-level events and some services available through the audit system table.
PostgreSQL troubleshooting looks beyond query plans
PostgreSQL guidance shows why an unchanged plan does not guarantee unchanged performance. Separate security guidance explains why private connectivity is not an authorization boundary.
Physical row ordering can dominate cold-cache lookups
A lookup that ran in tens of milliseconds on-premises took 1-2 seconds in Azure under cold-cache conditions. The slower environment stored 200 returned rows across 101 heap pages rather than five, after parallel loading interleaved related rows without changing the index scan plan.
VACUUM FULL did not help because it does not sort surviving rows by the lookup key. The customer reported improvement after testing pg_repack --order-by on a restored instance, making physical layout a useful investigation path rather than assuming the index plan explains all I/O.
Free space inside a table is not the same as a smaller table
On Azure PostgreSQL Flexible Server 16.15, the reported test table retained approximately 25 GB after autovacuum despite containing one live row, no dead tuples, and 99.61% free space. VACUUM FULL reduced it to 8192 bytes and reduced the recorded query time from 126103.317 ms to 0.067 ms.
This is a single-row example, not a general benchmark or an isolated measure of index bloat. VACUUM FULL needs an ACCESS EXCLUSIVE lock and additional disk space, while pg_repack consumes I/O, storage, and write-ahead log resources.
Private databases still need application and tool authorization
The MCP architecture guidance compares public MCP, private MCP, and public gateway deployments backed by private PostgreSQL Flexible Server. App Service VNet integration provides outbound connectivity, not private inbound access, and gateway deployments must block alternative public access to the backend to prevent bypassing Azure API Management policies.
Restricted workload permissions and database row-level security constrain access independently of MCP tool authorization. Private networking alone does not establish the identity, authority, or intent of the application making a request.
VS Code offers a short performance-investigation workflow
The walkthrough uses performance dashboards and Azure Advisor recommendations to investigate PostgreSQL issues from VS Code. It checks performance again after changes, keeping validation part of the workflow.
Azure SQL exposes more operational detail and clarifies architectural limits
Azure SQL coverage connects new diagnostics with explanations of storage, recovery, encryption, and application access. Several articles distinguish service capabilities from claims that require workload-specific testing or separate recovery evidence.
Version-store metrics explain reads hidden by unchanged plans
Azure SQL Database now exposes version-store read counters through STATISTICS IO, dynamic management views, extended events, and query plan XML. The counters distinguish tempdb, in-row persistent version store, off-row persistent version store, and online-index persistent version store reads, helping investigate CPU and logical-read increases caused by blocked version cleanup.
SSMS graphical plans do not yet display the counters, but actual plan XML contains them. Availability is expected soon for always-up-to-date Azure SQL Managed Instance and planned for the next SQL Server version.
Hyperscale distributes responsibilities, not primary writes
Hyperscale separates compute, log durability, page serving, and long-term storage while retaining one primary replica that accepts writes. The Socrates architecture describes compute nodes, XLOG, page servers, and XStore, with storage-tier snapshots providing near-instant backups without consuming database compute.
Storage grows automatically to 128 TB, with up to four high-availability replicas and 30 named replicas that can isolate reporting or AI work. Current log throughput reaches 150 MB/s, and serverless auto-pause and resume is in public preview. The reported comparison with Aurora is a Microsoft-commissioned benchmark at 16 vCores, not a workload-independent performance guarantee.
- Is Azure SQL Database Hyperscale “distributed SQL”?
- The paper that split the database in four: inside Azure SQL Database Hyperscale, aka Socrates
Backup inventory and restore capability answer different questions
On supported non-Hyperscale tiers, sys.dm_database_backups exposes backup types, timestamps, and retention flags, while Hyperscale returns no rows because it uses snapshots. The earliestRestoreDate property identifies the earliest available point-in-time restore time, which retention flags alone cannot establish.
Long-term retention preserves selected full backups for up to 10 years, but does not extend arbitrary point-in-time recovery across that period. Current policies and retained inventories cannot establish historical policy settings, and a completed test restore provides separate evidence that recovery works.
Accelerated recovery trades ongoing work for faster recovery
Accelerated Database Recovery is always on in Azure SQL Database and has been available, but off by default, in SQL Server since 2019. The reviewed paper reports 99.999th-percentile recovery falling from over one hour to three minutes and log usage for 50 million deletes falling from 38,255 MB to 147 MB.
The paper also reports throughput reductions of 13.8% on TPC-C with in-row versioning and 2.4% on TPC-E. SQL Server 2022 improved version-store cleanup, while SQL Server 2025 extends Accelerated Database Recovery to tempdb.
Encrypted queries depend on the enclave threat model
Always Encrypted protects a 32-byte AES column encryption key with a column master key stored outside the server. Secure enclaves enable range comparisons and LIKE queries over randomized encrypted columns, with SQL Server 2022 adding JOIN, GROUP BY, and ORDER BY operations inside enclaves.
Virtualization-based security enclaves are available across Azure SQL Database offerings in most regions, but currently lack enclave attestation. Intel SGX enclaves paired with Microsoft Azure Attestation provide the stronger protection matching the paper's threat model.
Python parameter binding supports named and positional styles
mssql-python now selects qmark placeholders for tuple or list parameters and pyformat named placeholders for dictionaries without configuration changes. Existing qmark queries need no changes, although the module-level paramstyle constant now reports pyformat.
Both styles use parameter binding rather than value interpolation, with named placeholders converted before ODBC execution. Unused dictionary keys are ignored, missing keys raise KeyError, and mixing styles can produce execution-time parameter count mismatches.
SQL MCP auto-configuration needs a security review
Data API builder's bundled configuration can expose every table in every schema through autoentities wildcard patterns. DAB_CONNSTRING overrides the primary configuration's connection string, and the deployment examples use image version 2.0.12.
The default configuration enables development tooling and anonymous create, read, update, and delete operations. That makes it unsuitable for production without reviewing what is exposed and who can mutate data.
Fuzzy matching addresses imperfect data without a model
The Data Exposed session compares fuzzy string matching with LIKE, Full-Text Search, and regular expressions. Examples cover customer lookup, product search, duplicate detection, master data management, and cleansing without requiring AI, embeddings, or vector databases.
Canadian time zone changes require platform-specific action
Affected Canadian locations retain UTC-07:00, UTC-06:00, and UTC-05:00 rather than turning clocks back on November 1, 2026. SQL Server on Windows requires the applicable Windows update for those definitions, while a known .NET TimeZoneInfo issue can apply incorrect offsets for one hour at the 2026/2027 year boundary.
Managed Instance instance-level time zones cannot be changed after creation without replacing the instance and migrating the workload. Database-level settings require the Always-up-to-date policy and do not change SQL Agent schedules or historical conversions.
The SQL roundup collects previews and tooling releases
The PASS Summit West roundup includes preview Hyperscale elastic pools supporting up to 50 databases and 128 TB per pool, depending on hardware and service objective, and automatic backup immutability that currently excludes Hyperscale. It also covers DiskANN vector search maintenance and SSMS 22.10.2, whose generally available features include GitHub Copilot Agent Mode, Database DevOps, Schema Compare, and SQL Formatter.
A Managed Instance report highlights backup-time throughput differences
A customer reports three consecutive backup-time slowdowns after moving a 4-vCore instance to Next-gen General Purpose, where default instance-wide allocation was approximately 83.2 MB/s versus a legacy data-file allowance of 210 MB/s. Reverting restored normal application performance in this case, making the report a reason to review throughput allocations during migration rather than evidence of a universal Next-gen regression.
Other Azure News
App Service plan-level start/stop is in public preview for Premium v4 and Premium memory-optimized v4, taking all hosted apps and slots offline while pausing compute billing, though other charges can continue. Operations are asynchronous and throttled to five minutes, automatic-scaling plans are unsupported, and teams must start plans before updates or scaling, wait for ongoing scaling to finish before start/stop operations, and check readiness before restoring traffic.
The BioNeMo integration uses the nvidia-rfd4-proteina agent in Microsoft Discovery to generate protein structures and amino acid sequences from natural-language requests, with a CPU-only Python 3.11 tool container separated from GPU inference. Inference can run through NVIDIA's hosted API, Microsoft Foundry, or AKS, and molecular data stays within the customer's Azure tenant when both the container and model run on AKS inside that tenant.
Application Gateway previews advanced routing with up to five AND-combined conditions, RE2 expressions, weighted or priority-based pool selection, and additional server-selection algorithms. API version 2026-03-01 or later is required, and preview weighted distribution ignores pool health while the previews have no service-level agreement.
Azure Managed Redis guidance describes eight caching patterns, with retail samples for PostgreSQL, Azure SQL Database, and Cosmos DB implementing seven because they deploy to a single region. The samples use DefaultAzureCredential, and the guidance recommends expiration-time jitter, database fallback, regional co-location, and monitoring hit ratio, evictions, and latency.
Azure NetApp Files guidance covers checkpoint writes, high-throughput NFS reads, writable short-term clones, and Trident-provisioned AKS volumes. Its object REST API provides access to NFS and SMB datasets without copying them into a separate object store, but the reference deployments report qualitative improvements rather than numerical performance comparisons.
- Azure NetApp Files: The Data Backbone for NVIDIA AI Model Training, Inference, and Microsoft Foundry
GitHub's October availability report says 140 of 151 production services and 32 of 50 MySQL primaries were running in Azure Central US as of November 9, with compute capacity more than doubled across nine Kubernetes clusters. It also reports an Actions service-path change that reduced peak database reads by 85%, alongside incidents involving writes routed to retired servers and an invalid upstream Copilot credential.
The guided Copilot experience for building Azure apps in VS Code now fully supports Python, with architecture approval before code generation and a review of deployment tools, resources, and estimated costs before deployment. A separate video demonstrates Container Apps sandboxes, AI Gateway model and tool tracking, SRE Agent operational assistance, and Copilot canvases for .NET developers.
- Python support has arrived in the guided Copilot experience for VS Code
- Azure's new lineup for .NET developers
Microsoft's sleeper-agent research shows that edits to fewer than ten neurons can create a triggered model backdoor, but Microsoft has not observed threat actors weaponizing the technique. The recommendation is to audit model weights before deployment and after updates alongside behavioral scanning, because Defender for Cloud's serialization and code-level scanning does not replace weight-level audits.
The Logic Apps, Functions, and generative AI example separates workflow coordination, technical processing, and incident summarization. Validation or human review checks proposed actions before execution.
The Azure weekly video covers the ending of .NET 8 and .NET 9 support in Static Web Apps, Functions .NET 11 support, Route Server dual-stack support, and Front Door gRPC, edge actions, and WAF rate-limit grouping. It also covers easier Arc-enabled Azure File Sync onboarding.
Thomas Maurer's sovereign AI session is available on NVIDIA On-Demand, covering connected and fully disconnected Foundry Local deployments on Azure Local. The article reports general availability of Foundry Local on Azure Local for Microsoft Ignite 2026 and discusses region selection, the EU Data Boundary, confidential computing, and Microsoft Purview as sovereign AI controls.
Also relevant this week
- Real-Time Multichannel Speech-to-Text is now generally available: Real-Time Multichannel Speech-to-Text is generally available in Azure Speech, supporting up to two channels independently within one continuous recognition session. Full story in the Artificial Intelligence roundup.
- Java OpenJDK August 2026 Critical Patch Update: The update provides Microsoft Build of OpenJDK versions 25.0.4.1, 21.0.12.1, 17.0.20.1, and 11.0.32.1. Full story in the Security roundup.
- Ask your database estate a question: Copilot in Database Hub is now in public preview: Copilot in Database Hub is now in public preview, answering questions using resource inventory, detected issues, and performance telemetry. Full story in the Artificial Intelligence roundup.
- Use OneLake as native storage for Azure Databricks: OneLake external-location support for Azure Databricks Unity Catalog is generally available in Microsoft Fabric, while the Azure Databricks side remains in preview. Full story in the Machine Learning roundup.
- How Azure Chaos Studio ships with hermetic Aspire end-to-end tests: Azure Chaos Studio comprises four independently shipped services: a control plane, execution plane, fault-execution plugin host, and data plane. Full story in the .NET roundup.
- When one pass isn’t enough: agentic mode in Azure Content Understanding: Agentic mode is now in preview and uses document-specific tools to navigate evidence, inspect visuals, calculate, and validate structured outputs. Full story in the Artificial Intelligence roundup.
- Azure Local security: closing the industry standards gap and improving enterprise adoption: Azure Local 2610 evaluates 429 security settings for domain-joined deployments and 403 for deployments using local identities. Full story in the Security roundup.
- EF Core 11: Vector Search, Smarter LINQ, and a Friendlier dotnet ef: The session covers approximate vector search and full-text search on SQL Server. Full story in the .NET roundup.
- Build a dual-mode voice agent in Microsoft Foundry with native subagents: Native voice subagents are in preview, and Microsoft does not recommend preview features for production workloads. Full story in the Artificial Intelligence roundup.
- From Python Agents to Copilot Harness : Putting Microsoft Foundry to the Test: The experiment replaces four hosted Microsoft Agent Framework wrappers with one Foundry-managed Copilot harness agent. Full story in the Artificial Intelligence roundup.
- Inside the Microsoft Copilot Harness: Customizing AI Agents: Patrick Nikoletich demonstrates a Dockerized agent worker pool with isolated containers. Full story in the Artificial Intelligence roundup.
- Multilingual Fabric data agents in Foundry: normalize values: The exploratory test used one synthetic 288-row Fabric warehouse table and graded 42 responses. Full story in the Artificial Intelligence roundup.
- Beyond Localhost: .NET Agents in Foundry: Session BRK031 examines hosted agents in Microsoft Foundry from a C# developer’s perspective. Full story in the Artificial Intelligence roundup.
- Microsoft Foundry with Adrian Twarog: Build Your First Agent: The walkthrough covers account setup, model exploration, agent creation, playground testing and agent publication in Microsoft Foundry. Full story in the Artificial Intelligence roundup.
- Microsoft Foundry: Keep Your AI Spend Under Control: Microsoft Foundry runs inside Azure. Full story in the Artificial Intelligence roundup.
- Microsoft Foundry: Test Your Agent Before You Ship: Adrian Twarog demonstrates building an agent and testing it in Microsoft Foundry’s playground. Full story in the Artificial Intelligence roundup.
- Resources for the SQL AI Developer: Passing Exam DP-800 earns the Microsoft Certified: SQL AI Developer Associate certification. Full story in the Artificial Intelligence roundup.
Dates to know
Deadlines
- 1 September 2027: End of support — Azure App Service; Azure Functions: Support for Java 8, 11, and 17 ends; existing applications continue running without related runtime updates or support. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- September 2027: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 11 and 17 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- September 2028: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 21 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- September 2030: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 25 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)