DailyAzureUpdatesGenerator

November 20, 2025 - Azure Updates Summary Report (Details Mode)

Generated on: November 20, 2025 Target period: Within the last 24 hours Processing mode: Details Mode Number of updates: 10 items

Update List

1. Generally Available: Azure Managed Lustre Support for Azure MCP Server

Published: November 19, 2025 21:00:38 UTC Link: Generally Available: Azure Managed Lustre Support for Azure MCP Server

Update ID: 529381 Data source: Azure Updates API

Categories: Launched, Storage, Azure Managed Lustre

Summary:

• What was updated
  Azure Managed Lustre now provides full integration with Azure MCP Server, and this feature is generally available.

• Key changes or new features
  Developers and IT professionals can now manage Azure Managed Lustre file systems directly through Azure MCP Server. This integration allows unified management of Azure resources using native Azure tools and APIs, streamlining deployment, configuration, and monitoring of Lustre file systems within Azure environments.

• Target audience affected
  Developers, infrastructure engineers, and IT operations teams who use Azure Managed Lustre for high-performance file storage and want centralized management via Azure MCP Server.

• Important notes if any
  This general availability release ensures production-ready support for managing Lustre file systems alongside other Azure resources, improving operational efficiency and automation capabilities. Users should leverage Azure MCP Server APIs for consistent resource management workflows.

Details:

The recent general availability of Azure Managed Lustre support for Azure MCP Server marks a significant enhancement in managing high-performance file systems within Azure’s cloud infrastructure. Azure Managed Lustre is a fully managed, high-throughput, low-latency file system optimized for HPC (High Performance Computing) and data-intensive workloads. Azure MCP Server (Microsoft Cloud Platform Server) is a management platform designed to provide unified control over Azure resources, enabling infrastructure teams and developers to automate and streamline resource management.

Background and Purpose
Prior to this update, managing Azure Managed Lustre file systems required using separate management interfaces or APIs, which could complicate automation and integration within broader cloud management workflows. The purpose of integrating Azure Managed Lustre with Azure MCP Server is to centralize and simplify resource management, enabling users to provision, monitor, and control Lustre file systems alongside other Azure resources through a consistent management plane. This integration supports operational efficiency, reduces management overhead, and enhances automation capabilities for HPC and data analytics environments.

Specific Features and Detailed Changes

• Full Integration with Azure MCP Server: Azure Managed Lustre file systems can now be managed directly via Azure MCP Server’s interface and APIs. This includes lifecycle operations such as creation, configuration, scaling, and deletion.
• Unified Resource Management: Lustre file systems appear as first-class resources within MCP Server, allowing users to incorporate them into resource groups, apply tags, and manage access policies consistently.
• Improved Automation: The integration enables infrastructure-as-code (IaC) scenarios using MCP Server’s automation tools, facilitating repeatable deployments and configuration management of Lustre file systems.
• Monitoring and Diagnostics: Enhanced telemetry and monitoring capabilities are accessible through MCP Server, enabling better visibility into performance metrics and operational health of Lustre file systems.

Technical Mechanisms and Implementation Methods
Azure MCP Server acts as a centralized management layer that communicates with Azure Resource Manager (ARM) APIs under the hood. The integration exposes Azure Managed Lustre resources through MCP Server’s management API endpoints, translating user commands into ARM operations. This abstraction allows users to manage Lustre file systems without directly interacting with ARM or Lustre-specific APIs. The implementation leverages Azure’s role-based access control (RBAC) to ensure secure and granular permissions when managing Lustre resources. Additionally, MCP Server supports scripting and automation via PowerShell and REST APIs, enabling integration into CI/CD pipelines and operational scripts.

Use Cases and Application Scenarios

• High Performance Computing (HPC): Researchers and engineers running simulations or large-scale computations can provision and manage Lustre file systems seamlessly alongside compute clusters.
• Big Data Analytics: Data scientists processing massive datasets benefit from simplified Lustre management integrated with their data pipelines.
• DevOps and Automation: Infrastructure teams can automate Lustre deployments as part of broader infrastructure provisioning workflows, improving consistency and reducing manual errors.
• Hybrid Cloud Environments: Organizations using MCP Server to manage hybrid or multi-cloud resources can now include Lustre file systems in their unified management strategy.

Important Considerations and Limitations

• Version Compatibility: Users must ensure that their MCP Server environment is updated to a version supporting the new Lustre integration.
• Access Control: Proper RBAC roles must be assigned to users and service principals to manage Lustre resources securely.
• Performance Monitoring: While monitoring is improved, users should still configure alerts and diagnostics tailored to their workload requirements.
• Regional Availability: The integration may initially be available in select Azure regions; users should verify availability in their target deployment zones.

Integration with Related Azure Services

• Azure Compute: Lustre file systems can be attached to Azure HPC VMs and clusters managed through MCP Server.
• Azure Monitor: Performance and health metrics from Lustre are integrated into Azure Monitor dashboards accessible via MCP Server.
• Azure Active Directory (AAD): Authentication and authorization for Lustre management are enforced

---

2. Generally Available: CSI Dynamic Provisioning for Azure Managed Lustre

Published: November 19, 2025 21:00:38 UTC Link: Generally Available: CSI Dynamic Provisioning for Azure Managed Lustre

Update ID: 529368 Data source: Azure Updates API

Categories: Launched, Storage, Azure Managed Lustre, Features, Management, Open Source, Services, Microsoft Ignite

Summary:

• What was updated
  Azure Managed Lustre (AMLFS) now supports Container Storage Interface (CSI) Dynamic Provisioning, and this feature is generally available.

• Key changes or new features
  Developers can now dynamically provision AMLFS-backed persistent volumes directly within Kubernetes clusters using standard StorageClass and PersistentVolumeClaim objects. This eliminates the need for pre-provisioning storage volumes manually, streamlining storage management for high-performance Lustre file systems in containerized environments.

• Target audience affected
  Kubernetes developers and IT professionals managing containerized applications requiring high-throughput, scalable shared storage on Azure. DevOps engineers and cloud architects integrating Lustre storage with Kubernetes workloads will benefit from simplified storage provisioning.

• Important notes if any
  Dynamic provisioning requires configuring appropriate StorageClass definitions referencing the AMLFS CSI driver. This update enhances automation and scalability for HPC and data-intensive workloads on Azure Kubernetes Service (AKS) or other Kubernetes platforms using AMLFS. Users should review the updated CSI driver documentation to implement dynamic provisioning correctly.

Details:

The recent general availability of CSI Dynamic Provisioning for Azure Managed Lustre (AMLFS) introduces a significant enhancement for Kubernetes workloads requiring high-performance, scalable file storage. Previously, provisioning Azure Managed Lustre file systems for Kubernetes involved manual steps to create and manage persistent volumes (PVs), which limited agility and automation. This update enables Kubernetes clusters to dynamically provision AMLFS-backed persistent volumes on demand using standard Kubernetes StorageClass and PersistentVolumeClaim (PVC) objects, streamlining storage management and improving developer productivity.

Background and Purpose
Azure Managed Lustre is a fully managed, high-performance parallel file system optimized for compute-intensive workloads such as HPC, AI/ML, and big data analytics. Kubernetes users deploying such workloads often require Lustre’s low-latency, high-throughput shared storage. Prior to this update, integrating AMLFS with Kubernetes involved static provisioning, where administrators had to manually create Lustre file systems and PVs before pods could consume them. This manual approach hindered DevOps automation and dynamic scaling. The introduction of CSI (Container Storage Interface) dynamic provisioning addresses these challenges by automating volume lifecycle management, aligning Lustre storage consumption with Kubernetes-native workflows.

Specific Features and Detailed Changes

• Dynamic Provisioning Support: Kubernetes pods can now request AMLFS volumes dynamically by specifying a StorageClass that references the Azure Managed Lustre CSI driver. When a PVC is created, the CSI driver automatically provisions a new AMLFS volume tailored to the request parameters.
• Standard Kubernetes APIs: Utilizes standard StorageClass and PVC APIs, enabling seamless integration with existing Kubernetes manifests and Helm charts without custom scripting.
• Parameterization: StorageClass parameters allow configuration of Lustre volume properties such as capacity, throughput, and deployment region, providing flexibility to meet workload requirements.
• Lifecycle Management: The CSI driver handles volume creation, attachment, mounting, and deletion, reducing operational overhead and potential for misconfiguration.

Technical Mechanisms and Implementation Methods
The Azure Managed Lustre CSI driver acts as a Kubernetes external provisioner that interfaces with Azure Resource Manager (ARM) APIs to create and manage AMLFS instances. When a PVC is submitted:

1. Kubernetes triggers the CSI provisioner to interpret the StorageClass parameters.
2. The provisioner calls ARM APIs to create a new AMLFS volume with specified capacity and performance characteristics.
3. Once provisioned, the volume is attached and mounted to the requesting pod using the CSI node plugin.
4. Upon PVC deletion, the CSI driver cleans up the AMLFS volume automatically.

This integration leverages Kubernetes CSI specifications for volume lifecycle operations and Azure’s REST APIs for resource provisioning, ensuring a cloud-native and declarative approach.

Use Cases and Application Scenarios

• High-Performance Computing (HPC): Dynamic Lustre volumes enable HPC workloads to scale storage on demand, improving resource utilization and reducing costs.
• AI/ML Pipelines: Data scientists can provision ephemeral Lustre volumes for training jobs, facilitating faster data access and parallel processing.
• Big Data Analytics: Analytics platforms running on Kubernetes can dynamically allocate Lustre storage for large datasets, optimizing throughput and latency.
• Dev/Test Environments: Developers can spin up isolated Lustre-backed storage environments quickly without manual intervention, accelerating development cycles.

Important Considerations and Limitations

• Region Availability: AMLFS dynamic provisioning is available only in supported Azure regions; users should verify regional support before deployment.
• Quota and Limits: Provisioned volumes consume Azure subscription quotas; administrators must monitor and manage quotas to avoid provisioning failures.
• Performance Tuning: While parameters allow some customization, optimal Lustre performance may require tuning beyond default settings, especially for specialized workloads.
• CSI Driver Versioning: Users must ensure compatibility between Kubernetes versions and the AMLFS CSI driver to avoid integration issues.
• Security: Proper role-based access control (RBAC)

---

3. Public Preview: 20 MB/s/TiB Performance Tier for Azure Managed Lustre

Published: November 19, 2025 21:00:38 UTC Link: Public Preview: 20 MB/s/TiB Performance Tier for Azure Managed Lustre

Update ID: 529359 Data source: Azure Updates API

Categories: In preview, Storage, Azure Managed Lustre

Summary:

• What was updated
  Azure Managed Lustre introduced a new 20 MB/s/TiB performance tier, now available in public preview.

• Key changes or new features
  This new tier significantly enhances throughput, allowing up to 20 MB/s per TiB of provisioned storage. It supports file systems up to 25 PiB in size, catering to very large-scale storage needs. The update is optimized for demanding AI and HPC workloads that require high throughput and massive parallelism.

• Target audience affected
  Developers and IT professionals working with large-scale AI, machine learning, and high-performance computing applications will benefit most. Organizations needing scalable, high-throughput shared file systems for data-intensive workloads will find this tier especially useful.

• Important notes if any
  As this feature is in public preview, users should evaluate it in non-production environments and provide feedback. Pricing and SLA details may differ from generally available tiers. Integration with existing Azure Managed Lustre deployments is seamless, but performance tuning may be required to maximize benefits.

For more details, visit: https://azure.microsoft.com/updates?id=529359

Details:

Azure Managed Lustre has introduced a new 20 MB/s/TiB performance tier, now available in public preview, aimed at addressing the performance requirements of large-scale AI and high-performance computing (HPC) workloads. This update significantly enhances throughput capacity by allowing customers to provision file systems up to 25 PiB in size, delivering a scalable and high-performance parallel file system optimized for demanding data-intensive applications.

Background and Purpose
Azure Managed Lustre is a fully managed, high-performance file system based on the open-source Lustre file system, widely used in HPC environments for its ability to provide low-latency, high-throughput access to shared data. As AI and HPC workloads grow in scale and complexity, the need for higher throughput per unit of storage has become critical. The introduction of the 20 MB/s/TiB tier addresses this by increasing the data throughput capability, enabling faster data processing and reduced job runtimes for large datasets.

Specific Features and Detailed Changes

• Performance Tier: The new tier offers 20 MB/s throughput per TiB of storage, doubling the throughput compared to previous tiers (typically 10 MB/s/TiB).
• Scalability: File systems can now be provisioned up to 25 PiB, supporting extremely large datasets common in AI training and HPC simulations.
• Throughput Optimization: This tier is optimized for workloads requiring sustained high throughput, such as machine learning model training, genomic sequencing, seismic analysis, and large-scale simulations.
• Public Preview Availability: Users can test and validate this tier before general availability, providing feedback and adapting workloads accordingly.

Technical Mechanisms and Implementation Methods
The increased throughput is achieved by enhancing the underlying infrastructure and tuning the Lustre file system parameters to better utilize Azure’s high-speed networking and storage hardware. This includes:

• Leveraging Azure’s RDMA-capable network fabric to reduce latency and increase data transfer rates.
• Optimizing metadata servers and object storage targets to handle higher I/O operations per second (IOPS).
• Employing parallelism in data striping across multiple storage targets to maximize throughput.
• Integration with Azure Blob storage as the backend, ensuring durability and scalability.

Use Cases and Application Scenarios

• AI and Machine Learning: Large-scale training datasets benefit from faster data loading and checkpointing, reducing overall training time.
• High-Performance Computing: Scientific simulations, weather modeling, and computational fluid dynamics require high throughput to process massive datasets efficiently.
• Media and Entertainment: Rendering farms and video processing pipelines can leverage increased throughput for faster content generation.
• Genomics and Life Sciences: Genomic data analysis workflows that process terabytes of data gain improved performance and scalability.

Important Considerations and Limitations

• As this tier is in public preview, it may not yet be covered by SLA guarantees and could have limited regional availability.
• Pricing for the 20 MB/s/TiB tier may differ from existing tiers; customers should evaluate cost-performance trade-offs.
• Workloads must be designed to take advantage of parallel I/O to fully utilize the increased throughput.
• Integration with existing Lustre deployments may require migration planning or reconfiguration.

Integration with Related Azure Services

• Azure HPC Cache: Can be used alongside Managed Lustre to accelerate data access for on-premises HPC clusters.
• Azure Machine Learning: Managed Lustre can serve as a high-throughput data store for training datasets.
• Azure Batch and Azure CycleCloud: These orchestration services can provision compute clusters that directly mount Managed Lustre file systems for scalable HPC workloads.
• Azure Blob Storage: Acts as the durable backend storage layer, ensuring data persistence and integration with Azure storage management.

In summary, the new 20 MB/s/TiB performance tier for Azure Managed Lustre in public preview offers a substantial throughput increase and enhanced scalability, designed

---

4. Public Preview: Auto-import for Azure Managed Lustre

Published: November 19, 2025 20:00:49 UTC Link: Public Preview: Auto-import for Azure Managed Lustre

Update ID: 529342 Data source: Azure Updates API

Categories: In preview, Storage, Azure Managed Lustre, Features, Microsoft Ignite, Services

Summary:

• What was updated
  Azure Managed Lustre File System (AMLFS) now supports the Auto-import feature, released in public preview.

• Key changes or new features
  Auto-import enables automatic, policy-driven synchronization of data from Azure Blob Storage containers into AMLFS clusters. This feature continuously monitors Blob Storage for new or modified files and imports them into the Lustre file system without manual intervention, ensuring data consistency and reducing operational overhead. It simplifies workflows that rely on up-to-date data in high-performance Lustre environments by automating data refresh processes.

• Target audience affected
  Developers and IT professionals managing high-performance computing (HPC) workloads, data engineers, and architects using Azure Managed Lustre for scalable, high-throughput file storage integrated with Blob Storage.

• Important notes if any
  As a public preview feature, Auto-import should be used with caution in production environments. Users should review the preview limitations and provide feedback to Microsoft. Integration requires proper configuration of synchronization policies and permissions between AMLFS and Blob Storage. This feature enhances data orchestration capabilities in Azure HPC scenarios.

For more details, visit: https://azure.microsoft.com/updates?id=529342

Details:

The Azure update announces the public preview release of the Auto-import feature for Azure Managed Lustre File System (AMLFS), designed to enhance data synchronization workflows between Azure Blob Storage and AMLFS clusters. This feature addresses the need for automated, policy-driven data consistency in high-performance computing (HPC) and big data analytics environments that leverage Lustre’s parallel file system capabilities alongside the scalability of Azure Blob Storage.

Background and Purpose:
Azure Managed Lustre is a fully managed, high-throughput, low-latency file system optimized for HPC and large-scale data processing workloads. Traditionally, users manually synchronize data between Azure Blob Storage and AMLFS, which can be error-prone and operationally intensive. The Auto-import feature was introduced to automate this synchronization, ensuring that AMLFS clusters automatically reflect changes—such as additions, modifications, or deletions—in the underlying Blob Storage containers. This reduces manual intervention, improves data freshness, and streamlines workflows.

Specific Features and Detailed Changes:

• Policy-driven synchronization: Users can define import policies that specify which Blob Storage containers and directories are monitored for changes.
• Automatic detection of changes: The system continuously detects new, updated, or deleted blobs and imports these changes into the AMLFS namespace without manual triggers.
• Incremental updates: Only changed data is synchronized, optimizing performance and reducing unnecessary data transfer.
• Seamless integration: The feature works transparently with existing AMLFS clusters, requiring minimal configuration.
• Public preview availability: Users can enable and test this feature in their environments, providing feedback before general availability.

Technical Mechanisms and Implementation Methods:
Auto-import leverages event-driven architecture and Azure Blob Storage change feed or event grid notifications to detect changes in the source containers. Upon detecting a change, the AMLFS control plane initiates incremental synchronization operations that import or update files in the Lustre file system namespace. The synchronization respects Lustre’s metadata and file system semantics, ensuring consistency and coherence. The feature is implemented as a background service integrated with the AMLFS management layer, orchestrating data movement and metadata updates without impacting cluster performance.

Use Cases and Application Scenarios:

• HPC workloads: Scientific simulations or financial modeling that require up-to-date input datasets stored in Blob Storage to be available in AMLFS for fast parallel processing.
• Big data analytics: Data lakes where raw data lands in Blob Storage and needs to be rapidly accessible in Lustre for analytics or machine learning pipelines.
• Media rendering and transcoding: Large media files stored in Blob Storage can be automatically imported into AMLFS for high-throughput rendering tasks.
• Backup and archival workflows: Synchronizing archival data from Blob Storage into AMLFS for on-demand access without manual copying.

Important Considerations and Limitations:

• As a public preview feature, Auto-import may have limitations in scale, performance, or supported scenarios and is not recommended for production-critical workloads without validation.
• Users must configure appropriate access permissions and network connectivity between AMLFS clusters and Blob Storage containers.
• The synchronization latency depends on the frequency of change detection and the volume of data changes.
• Conflict resolution policies and error handling mechanisms should be understood and tested to avoid data inconsistencies.
• Monitoring and logging should be enabled to track synchronization status and troubleshoot issues.

Integration with Related Azure Services:

• Azure Blob Storage: Acts as the source data repository, with Auto-import monitoring containers for changes.
• Azure Event Grid / Change Feed: Underpins the event-driven detection of blob changes that trigger synchronization.
• Azure Monitor: Can be used to track metrics and logs related to Auto-import operations.
• Azure Active Directory: Manages authentication and authorization for secure access between AMLFS and Blob Storage.
• Azure HPC and AI services: AMLFS with Auto-import can be integrated into broader HPC and AI pipelines for seamless data workflows.

In summary,

---

5. Public Preview: Recommended alerts for Azure Monitor Workspace

Published: November 19, 2025 17:45:05 UTC Link: Public Preview: Recommended alerts for Azure Monitor Workspace

Update ID: 515505 Data source: Azure Updates API

Categories: In preview, Compute, Containers, DevOps, Management and governance, Azure Kubernetes Service (AKS), Azure Monitor, Features

Summary:

• What was updated
  Azure Monitor introduced a public preview feature that allows one-click enablement of recommended alerts within the Azure Portal, specifically for Azure Monitor Managed Service for Prometheus customers.

• Key changes or new features
  The update provides pre-configured alerts focused on monitoring ingestion limits for Azure Monitor Workspaces. These recommended alerts help users proactively track and manage data ingestion to prevent hitting workspace limits, ensuring uninterrupted monitoring and metric collection. The alerts can be enabled quickly without manual configuration, streamlining alert setup for Prometheus users.

• Target audience affected
  This update primarily targets developers and IT professionals using Azure Monitor Managed Service for Prometheus who need to monitor their workspace ingestion metrics effectively. It also benefits monitoring and operations teams responsible for maintaining Azure Monitor health and performance.

• Important notes if any
  The feature is currently in public preview, so users should evaluate it in non-production environments before full adoption. Enabling these alerts helps avoid data loss or monitoring gaps caused by ingestion limit breaches. Users should monitor Azure updates for GA announcements and additional alert recommendations.

Link: https://azure.microsoft.com/updates?id=515505

Details:

The recent Azure update introduces a Public Preview feature enabling one-click activation of recommended alerts within the Azure Portal specifically for Azure Monitor Managed Service for Prometheus users. This enhancement primarily targets improved observability and proactive management of Azure Monitor Workspace ingestion limits, thereby helping IT professionals prevent metric ingestion bottlenecks and ensure uninterrupted monitoring workflows.

Background and Purpose of the Update
Azure Monitor Managed Service for Prometheus allows customers to ingest Prometheus metrics into Azure Monitor Workspaces, facilitating unified monitoring across cloud-native and traditional workloads. However, ingestion limits on Azure Monitor Workspaces can lead to dropped metrics or throttling if not properly managed. Prior to this update, configuring alerts to track ingestion thresholds required manual setup and expertise, potentially leading to delayed detection of ingestion issues. The update aims to simplify this process by providing pre-configured, recommended alerts that can be enabled with a single click, enhancing operational efficiency and reducing the risk of missing critical metric data.

Specific Features and Detailed Changes

• One-Click Enablement: Users can now activate a curated set of recommended alerts directly from the Azure Portal without manual rule creation.
• Focus on Ingestion Limits: The alerts specifically monitor Azure Monitor Workspace ingestion metrics, such as data volume and rate, to detect when thresholds approach limits that could impact data ingestion.
• Integration with Azure Monitor Managed Service for Prometheus: These alerts are tailored for Prometheus metrics ingestion scenarios, ensuring relevance and accuracy.
• Predefined Alert Logic: The recommended alerts come with predefined thresholds and logic based on best practices, reducing the need for custom configuration.

Technical Mechanisms and Implementation Methods
Under the hood, these recommended alerts leverage Azure Monitor’s alerting framework, which supports metric alerts based on workspace-level telemetry. The system monitors ingestion-related metrics exposed by the Azure Monitor Workspace resource provider, such as ingestion volume and throttling events. When enabled, the alert rules continuously evaluate these metrics against predefined thresholds. Upon breach, alerts trigger notifications or automated actions as configured by the user. The one-click enablement feature is implemented as a portal-integrated workflow that programmatically creates these alert rules with appropriate scopes and conditions, streamlining deployment.

Use Cases and Application Scenarios

• Proactive Monitoring of Ingestion Quotas: IT teams can prevent data loss by receiving early warnings when ingestion volumes near workspace limits.
• Capacity Planning: Alerts provide visibility into ingestion trends, aiding in scaling decisions or workspace tier adjustments.
• Operational Reliability: Ensures continuous observability by avoiding silent metric drops due to ingestion throttling.
• Managed Service for Prometheus Deployments: Particularly beneficial for customers using Prometheus metrics in Azure Monitor, simplifying alert management.

Important Considerations and Limitations

• Preview Status: As a public preview feature, it may be subject to changes and should be tested in non-production environments initially.
• Scope of Alerts: Currently focused on ingestion limits; other alert types may require manual configuration.
• Notification Configuration: While alerts are preconfigured, users must still set up action groups or notification channels to receive alerts.
• Workspace Compatibility: Applicable only to Azure Monitor Workspaces integrated with the Managed Service for Prometheus.

Integration with Related Azure Services

• Azure Monitor: The alerts are built on Azure Monitor’s native alerting infrastructure, ensuring seamless integration with existing monitoring setups.
• Azure Portal: The one-click enablement is accessed via the Azure Portal UI, enhancing usability.
• Azure Action Groups: Alerts can trigger notifications or automated responses through Azure Action Groups, enabling integration with ITSM tools, email, SMS, or webhook endpoints.
• Azure Managed Service for Prometheus: The feature directly supports this service, aligning with Azure’s strategy for cloud-native monitoring.

In summary, this update streamlines the configuration of critical ingestion limit alerts for Azure Monitor Workspaces used with the Managed Service for Prometheus,

---

6. Public Preview: Azure Managed Redis integration with Microsoft Foundry

Published: November 19, 2025 17:30:18 UTC Link: Public Preview: Azure Managed Redis integration with Microsoft Foundry

Update ID: 532188 Data source: Azure Updates API

Categories: In preview, AI + machine learning, Microsoft Foundry

Summary:

• What was updated
  Azure Managed Redis is now integrated into the Microsoft Foundry MCP tools catalog and is available in public preview.

• Key changes or new features
  This integration enables developers to easily connect Azure Managed Redis as a knowledge store or memory store for AI agents built on the Foundry platform. It simplifies the process of leveraging Redis for fast, scalable caching and state management within AI workloads, enhancing agent performance and responsiveness.

• Target audience affected
  Developers building AI agents using Microsoft Foundry, IT professionals managing AI infrastructure, and architects designing scalable AI solutions that require efficient memory or knowledge storage.

• Important notes if any
  The feature is currently in public preview, so users should evaluate it in non-production environments and provide feedback. Integration streamlines Redis connectivity but requires familiarity with both Azure Managed Redis and Microsoft Foundry MCP tools. Monitoring and scaling Redis instances remain critical for optimal AI agent performance.

For more details, visit: https://azure.microsoft.com/updates?id=532188

Details:

The recent public preview announcement of Azure Managed Redis integration with Microsoft Foundry introduces a significant enhancement for developers building AI agents within the Foundry environment by enabling seamless use of Redis as a high-performance knowledge or memory store. This update reflects Microsoft’s strategic effort to streamline state management and data caching for AI workloads, leveraging Redis’s low-latency, in-memory data capabilities directly within the Foundry MCP (Microsoft Cloud Platform) tools catalog.

Background and Purpose:
Microsoft Foundry is a platform designed to accelerate the development and deployment of AI agents by providing a modular, scalable environment with integrated tools and services. AI agents often require fast, reliable access to transient or persistent state information—such as session memory, knowledge bases, or contextual data—to operate effectively. Azure Managed Redis, a fully managed, scalable, and secure Redis service, is widely recognized for its sub-millisecond latency and support for complex data structures. Integrating Managed Redis into Foundry addresses the need for a native, performant memory store that can be easily provisioned and managed alongside AI agent components, reducing architectural complexity and operational overhead.

Specific Features and Changes:

• Catalog Availability: Azure Managed Redis is now listed in the Microsoft Foundry MCP tools catalog, making it directly accessible for Foundry-based AI agent projects without requiring separate provisioning steps.
• Simplified Connectivity: The integration provides built-in connectors and configuration templates that enable Foundry agents to connect to Redis instances with minimal setup, including automated handling of authentication, endpoint discovery, and network configuration.
• Optimized for AI Workloads: The Redis instances provisioned through Foundry are pre-configured with settings optimized for AI agent memory and knowledge store patterns, such as eviction policies and throughput tuning.
• Support for Redis Data Structures: Agents can leverage Redis data types (strings, hashes, lists, sets, sorted sets, streams) to implement various memory models, including session state, conversation history, and real-time knowledge graphs.

Technical Mechanisms and Implementation:
Under the hood, this integration leverages Azure Managed Redis’s REST APIs and SDKs, combined with Foundry’s orchestration and deployment pipelines. When a developer selects Redis from the Foundry catalog, the platform automates the creation of a Redis instance within the user’s Azure subscription, configures network security groups or private endpoints for secure access, and injects connection strings and credentials into the agent runtime environment. The Foundry agent runtime includes Redis client libraries compatible with common programming languages used in AI development (e.g., Python, C#, Node.js), enabling direct interaction with Redis data stores. Additionally, telemetry and monitoring hooks are integrated to track Redis performance and usage metrics within the Foundry monitoring dashboards.

Use Cases and Application Scenarios:

• Conversational AI: Storing user session data, dialogue context, and entity recognition results to maintain state across interactions.
• Knowledge Graph Caching: Caching frequently accessed knowledge graph fragments or inference results to accelerate query response times.
• Real-time Data Processing: Using Redis streams to manage event-driven workflows or message queues within AI pipelines.
• Agent Memory: Implementing short-term and long-term memory models for AI agents to recall past interactions or learned information dynamically.

Important Considerations and Limitations:

• Preview Status: As a public preview feature, users should expect potential changes in API behavior, performance characteristics, or integration workflows. Production use should be carefully evaluated with appropriate testing.
• Scaling Constraints: While Azure Managed Redis supports scaling, the preview integration may have preset limits on instance sizes or throughput to ensure stability within Foundry.
• Security: Proper configuration of network isolation (e.g., VNet integration, private endpoints) and access controls is critical to safeguard sensitive AI data stored in Redis.
• Data Persistence: Redis is primarily an in-memory store; while persistence options exist, users should architect for data durability accordingly, especially for critical knowledge stores.

---

7. Generally Available: TLS and TCP termination on Azure Application Gateway

Published: November 19, 2025 17:00:30 UTC Link: Generally Available: TLS and TCP termination on Azure Application Gateway

Update ID: 532202 Data source: Azure Updates API

Categories: Launched, Networking, Security, Application Gateway

Summary:

• What was updated
  Azure Application Gateway now generally supports TLS and TCP protocol termination.

• Key changes or new features
  This update enables Application Gateway to load balance and securely terminate non-HTTP(S) traffic using TCP and TLS protocols. Previously focused on HTTP/HTTPS, the gateway can now handle encrypted and unencrypted TCP-based workloads, expanding its applicability to a broader range of applications. This includes decrypting TLS traffic at the gateway, allowing inspection, routing, and policy enforcement before forwarding to backend servers.

• Target audience affected
  Developers and IT professionals managing applications that rely on TCP or TLS protocols beyond HTTP/HTTPS will benefit. Network architects and security teams can leverage this to simplify infrastructure by consolidating load balancing and TLS termination within Application Gateway.

• Important notes if any
  Ensure backend pools and health probes are configured appropriately for TCP/TLS workloads. Review security policies to accommodate decrypted traffic at the gateway. This feature is now generally available, so it is production-ready for critical workloads.

For more details, visit: https://azure.microsoft.com/updates?id=532202

Details:

Azure Application Gateway’s general availability of TLS and TCP termination marks a significant enhancement in its capability to handle non-HTTP(S) traffic, extending its traditional role beyond Layer 7 (application layer) load balancing to also support Layer 4 (transport layer) protocols. This update addresses the growing need for secure and scalable load balancing of applications that communicate over TCP or TLS protocols but do not necessarily use HTTP(S).

Background and Purpose of the Update
Historically, Azure Application Gateway has been optimized for HTTP and HTTPS traffic, providing advanced Layer 7 load balancing features such as URL-based routing, SSL offloading, and Web Application Firewall (WAF) integration. However, many enterprise and cloud-native applications rely on other protocols over TCP or TLS, such as MQTT, FTP over TLS, or custom TCP-based protocols. Prior to this update, handling such traffic required alternative load balancing solutions like Azure Load Balancer or third-party appliances, which lack the integrated security and routing capabilities of Application Gateway. The introduction of TLS and TCP termination enables Application Gateway to natively manage these protocols, simplifying architecture and improving security posture.

Specific Features and Detailed Changes

• TCP and TLS Protocol Termination: Application Gateway can now terminate inbound TCP and TLS connections, decrypt TLS traffic when applicable, and then forward the traffic to backend pools. This allows for centralized certificate management and offloading of encryption workloads from backend servers.
• Load Balancing for Non-HTTP(S) Traffic: Supports load balancing of raw TCP streams and TLS-encrypted traffic, enabling scenarios such as secure MQTT broker clusters or database proxies.
• TLS Offloading and Re-encryption: For TLS traffic, Application Gateway can terminate the TLS session and optionally re-encrypt the traffic when forwarding to backend targets, maintaining end-to-end encryption if required.
• Health Probes for TCP/TLS: Health monitoring mechanisms are extended to support TCP-level probes, ensuring backend availability is accurately tracked for non-HTTP services.
• Integration with Existing Features: The update maintains compatibility with existing Application Gateway features such as autoscaling, zone redundancy, and diagnostics.

Technical Mechanisms and Implementation Methods
Application Gateway operates as a reverse proxy and load balancer. With this update, it listens on specified frontend IPs and ports configured for TCP or TLS protocols. When TLS termination is enabled, the gateway uses uploaded SSL certificates to decrypt incoming traffic. For TCP termination, it simply proxies the TCP stream to backend pool members based on configured load balancing rules. Backend pools are defined by IP addresses or FQDNs, and health probes use TCP SYN or TLS handshake checks to verify backend health. Configuration is managed via Azure Portal, ARM templates, CLI, or PowerShell, where listeners can be set to TCP or TLS protocols instead of HTTP/HTTPS.

Use Cases and Application Scenarios

• IoT and Messaging Protocols: Secure load balancing of MQTT brokers or AMQP services that use TLS for encryption.
• Database Proxies and Custom TCP Services: Load balancing encrypted database connections (e.g., MySQL over TLS) or custom TCP-based applications requiring centralized certificate management.
• Legacy Applications: Modernizing legacy TCP-based applications by introducing TLS termination and centralized traffic management without modifying backend services.
• Hybrid Architectures: Securely exposing on-premises TCP/TLS services via Application Gateway in hybrid cloud scenarios.

Important Considerations and Limitations

• No Layer 7 Features for TCP/TLS: Advanced Layer 7 routing (e.g., URL-based routing, WAF) remains exclusive to HTTP/HTTPS traffic; TCP/TLS termination supports only Layer 4 load balancing.
• Certificate Management: Certificates for TLS termination must be uploaded and managed within Application Gateway; automation of certificate renewal (e.g., via Key Vault integration) should be planned.
• Backend Compatibility: Backend services must be capable of handling decrypted or re-encrypted traffic as per the

---

8. Public Preview: Microsoft Foundry data connection for Azure Databricks

Published: November 19, 2025 17:00:30 UTC Link: Public Preview: Microsoft Foundry data connection for Azure Databricks

Update ID: 527678 Data source: Azure Updates API

Categories: In preview, AI + machine learning, Analytics, Azure Databricks

Summary:

• What was updated
  Azure Databricks Genie now supports integration with Microsoft Foundry via a new data connection, currently in public preview.

• Key changes or new features
  Developers and data engineers can connect Genie spaces directly to Microsoft Foundry agents using the Model Context Protocol (MCP). This enables seamless, secure access to trusted and governed data within Foundry, simplifying data ingestion and enhancing data lineage and context for AI and analytics workloads in Azure Databricks.

• Target audience affected
  This update primarily benefits developers, data scientists, and IT professionals working with Azure Databricks and Microsoft Foundry who require streamlined, governed data access for building intelligent applications and analytics pipelines.

• Important notes if any
  As this feature is in public preview, users should evaluate it in non-production environments and provide feedback. Integration relies on MCP, so familiarity with this protocol and Foundry agent configuration is recommended to maximize benefits. Keep an eye on Azure updates for general availability and additional enhancements.

Details:

The recent public preview announcement of the Microsoft Foundry data connection for Azure Databricks introduces a direct integration between Azure Databricks Genie and Microsoft Foundry, enabling seamless, secure access to trusted enterprise data within Databricks environments. This update is designed to streamline data workflows by leveraging the Model Context Protocol (MCP) to connect Genie spaces to Foundry agents, facilitating a more efficient and governed data analytics process.

Background and Purpose
Azure Databricks Genie is a collaborative environment that simplifies data engineering and machine learning workflows on Databricks. Microsoft Foundry is a data operations platform that provides data governance, cataloging, and operationalization capabilities. Prior to this update, accessing Foundry-managed data within Databricks required complex manual integration or data duplication, which could lead to data inconsistencies and governance challenges. The purpose of this update is to bridge these platforms natively, enabling Databricks users to directly query and utilize trusted data assets managed by Foundry without leaving the Databricks environment, thereby enhancing productivity and data governance.

Specific Features and Detailed Changes

• Direct Data Connection via MCP: The integration uses the Model Context Protocol (MCP), an open standard for data and model context exchange, to connect Genie spaces with Foundry agents. This allows Databricks notebooks and jobs to access Foundry datasets and metadata dynamically.
• Seamless Access to Trusted Data: Users can browse, discover, and query Foundry datasets directly from within Databricks, ensuring data lineage and governance policies are enforced.
• Public Preview Availability: The feature is currently in public preview, allowing early adopters to test and provide feedback before general availability.

Technical Mechanisms and Implementation Methods
The integration leverages MCP to establish a secure, authenticated communication channel between Azure Databricks Genie and Microsoft Foundry. MCP acts as a protocol layer that standardizes the interaction with Foundry’s data agents, exposing datasets and metadata in a consumable format. Implementation involves configuring Genie spaces with Foundry agent endpoints and appropriate authentication credentials, typically using Azure Active Directory (AAD) for identity management. Once connected, Databricks notebooks can invoke MCP APIs to query datasets, retrieve schema information, and maintain data context throughout the analytics lifecycle.

Use Cases and Application Scenarios

• Data Science and Machine Learning: Data scientists can directly access curated, governed datasets from Foundry within Databricks notebooks, accelerating model development without data duplication.
• Data Engineering Pipelines: Engineers can build ETL/ELT pipelines that consume Foundry data assets, ensuring compliance with enterprise data governance policies.
• Operational Analytics: Business analysts can run real-time analytics on trusted data sources, improving decision-making accuracy.
• Governed Data Sharing: Organizations can enforce data access policies centrally in Foundry while enabling flexible analytics in Databricks.

Important Considerations and Limitations

• Preview Status: As a public preview feature, it may have limited SLA guarantees and could undergo significant changes before GA. Production use should be approached cautiously.
• Authentication and Permissions: Proper configuration of AAD roles and permissions is critical to ensure secure and compliant data access.
• Performance Implications: Query performance depends on the underlying Foundry data infrastructure and network latency between Databricks and Foundry agents.
• Feature Scope: Currently, the integration focuses on data access and may not support all Foundry features such as advanced data transformations or lineage visualization directly within Databricks.

Integration with Related Azure Services

• Azure Active Directory: Used for secure authentication and authorization between Databricks and Foundry.
• Azure Databricks: Acts as the compute and analytics platform consuming Foundry data via Genie.
• Microsoft Foundry: Provides the data governance, cataloging, and operational data platform that manages the trusted data assets.
• Azure Networking: Proper network configuration (e.g.,

---

9. Public Preview: Azure Databricks Genie in Copilot Studio

Published: November 19, 2025 17:00:30 UTC Link: Public Preview: Azure Databricks Genie in Copilot Studio

Update ID: 527668 Data source: Azure Updates API

Categories: In preview, AI + machine learning, Analytics, Azure Databricks

Summary:

• What was updated
  Azure Databricks Genie has been integrated into Microsoft Copilot Studio and is now available in public preview.

• Key changes or new features
  This integration enables users to access intelligent, enterprise-grade AI-driven answers and conversational analytics directly across their entire Azure Databricks data estate. It leverages advanced AI capabilities to provide natural language querying and insights, enhancing data exploration and decision-making workflows within Copilot Studio.

• Target audience affected
  Developers, data engineers, data scientists, and IT professionals who work with Azure Databricks and seek to streamline data analytics through AI-powered conversational interfaces will benefit from this update.

• Important notes if any
  As this feature is in public preview, users should evaluate it in non-production environments and provide feedback. Integration requires appropriate Azure Databricks and Copilot Studio configurations and permissions to access enterprise data securely. This update represents a step toward more intuitive, AI-driven data analytics within Azure’s ecosystem.

Details:

The recent public preview release of Azure Databricks Genie within Microsoft Copilot Studio represents a significant advancement in enabling conversational AI-driven analytics directly on enterprise data housed in Azure Databricks. This integration is designed to empower data engineers, data scientists, and business analysts by providing an intelligent, natural language interface to query, analyze, and derive insights from large-scale data environments without requiring deep SQL or Spark expertise.

Background and Purpose
Azure Databricks is a leading unified analytics platform optimized for Apache Spark, widely used for big data processing and machine learning workloads. However, interacting with complex data lakes and data warehouses often requires specialized skills in query languages and data engineering. Microsoft Copilot Studio is a platform that integrates AI capabilities to facilitate natural language interactions with enterprise data. By embedding Azure Databricks Genie—an AI-powered conversational analytics engine—into Copilot Studio, Microsoft aims to democratize access to advanced analytics, reducing the barrier to entry for data exploration and accelerating decision-making processes.

Specific Features and Detailed Changes

• Conversational Analytics Interface: Users can now pose natural language questions about their data stored in Azure Databricks, and Genie translates these queries into optimized Spark SQL or PySpark commands executed in the Databricks environment.
• Enterprise-Grade AI Answers: Genie leverages large language models (LLMs) fine-tuned for enterprise data contexts, ensuring responses are accurate, context-aware, and compliant with organizational data governance policies.
• Full Data Estate Coverage: The integration supports querying across the entire Azure Databricks data estate, including Delta Lake tables, structured and unstructured data, enabling comprehensive insights.
• Interactive Query Refinement: Users can iteratively refine queries through follow-up questions, enabling exploratory data analysis in a conversational manner.
• Copilot Studio Integration: Genie is accessible directly within the Copilot Studio interface, providing a unified experience alongside other AI tools and workflows.

Technical Mechanisms and Implementation Methods
Azure Databricks Genie operates by interfacing with the Azure Databricks REST APIs and SQL endpoints. When a user submits a natural language query via Copilot Studio, the system uses an LLM-based natural language understanding (NLU) layer to parse and interpret the intent. The query is then translated into Spark SQL or PySpark code optimized for the underlying data schema and executed on the Databricks cluster. Results are returned and rendered within Copilot Studio’s conversational UI. The system incorporates enterprise security and compliance features, including Azure Active Directory (AAD) authentication, role-based access control (RBAC), and data masking where applicable. Additionally, Genie can leverage metadata from the Databricks Unity Catalog to understand data lineage and schema, improving query accuracy and governance adherence.

Use Cases and Application Scenarios

• Business Intelligence and Reporting: Non-technical business users can generate reports and dashboards by simply asking questions in natural language, accelerating time-to-insight.
• Data Exploration and Discovery: Data scientists and analysts can quickly explore datasets without writing complex queries, facilitating hypothesis generation and validation.
• Operational Analytics: IT and operations teams can monitor system metrics and logs stored in Databricks by querying conversationally, enabling proactive issue detection.
• Machine Learning Feature Engineering: Data engineers can interactively query and transform data to prepare features for ML models, streamlining workflows.
• Cross-Functional Collaboration: By lowering technical barriers, diverse teams can collaboratively analyze data within a shared conversational interface.

Important Considerations and Limitations

• Preview Status: As a public preview feature, Genie may have limitations in scalability, performance, or feature completeness and should not yet be used in critical production environments.
• Data Privacy and Compliance: Organizations must ensure that AI-generated queries and responses comply with internal data governance and regulatory requirements.
• Query Complexity: While Genie handles many query types, extremely complex analytical queries or custom Spark jobs may still require manual coding.

---

10. Public Preview: Azure API Management adds support for A2A Agent APIs

Published: November 19, 2025 17:00:30 UTC Link: Public Preview: Azure API Management adds support for A2A Agent APIs

Update ID: 527635 Data source: Azure Updates API

Categories: In preview, Integration, Internet of Things, Mobile, Web, API Management

Summary:

• What was updated
  Azure API Management now publicly supports Agent-to-Agent (A2A) APIs, enabling unified management of these APIs alongside existing API types.

• Key changes or new features
  The update introduces the ability to onboard, manage, and govern A2A APIs within the Azure API Management platform. This includes APIs used for AI model interactions, Model Context Protocol (MCP) tools, and traditional APIs. Organizations can now apply consistent policies, security, monitoring, and lifecycle management to agent APIs, improving operational efficiency and governance.

• Target audience affected
  Developers building AI-driven or agent-based applications, IT professionals managing API ecosystems, and architects designing integrated API strategies will benefit from this enhancement.

• Important notes if any
  This feature is currently in public preview, so users should evaluate it in non-production environments and provide feedback. As a preview, some functionalities may evolve before general availability. Users should review Azure’s documentation for any limitations or prerequisites.

This update streamlines API management for emerging agent-based architectures, supporting broader AI and automation integration scenarios within Azure.

Details:

The recent public preview announcement of Azure API Management (APIM) support for Agent-to-Agent (A2A) APIs introduces a significant enhancement enabling organizations to manage and govern agent APIs alongside existing API types such as AI model APIs, Model Context Protocol (MCP) tools, and traditional RESTful APIs. This update addresses the growing need to streamline API governance in environments where autonomous agents or AI-driven components communicate directly, facilitating unified lifecycle management, security, and monitoring within a single API management platform.

Background and Purpose
As enterprises increasingly adopt AI agents and autonomous systems that interact programmatically, the complexity of managing these agent APIs separately from traditional APIs has grown. Previously, Azure APIM focused on managing external-facing or internal REST APIs but lacked native support for agent-specific API protocols and communication patterns. The introduction of A2A API support aims to bridge this gap by enabling organizations to onboard, secure, and monitor agent APIs with the same rigor and tooling as other API types, thereby simplifying governance and operational consistency.

Specific Features and Detailed Changes

• A2A API Onboarding: Azure APIM now supports the registration and management of agent APIs, which typically involve asynchronous, event-driven, or protocol-specific interactions between agents.
• Unified API Catalog: Agent APIs appear alongside AI model APIs, MCP tools, and traditional APIs within the APIM developer portal and management plane, providing a consolidated view.
• Policy Application: Existing APIM policies (e.g., rate limiting, authentication, transformation) can be applied to agent APIs, enabling consistent security and traffic management.
• Telemetry and Monitoring: Enhanced telemetry captures agent API-specific metrics and logs, facilitating operational insights and troubleshooting.
• Support for Protocols: While traditional APIs often use HTTP/REST, A2A APIs may use specialized protocols; APIM adapts to support these communication patterns, though specifics depend on the agent framework used.

Technical Mechanisms and Implementation Methods
Under the hood, Azure APIM extends its API gateway capabilities to recognize and route agent API calls, which may involve message queues, event hubs, or protocol adapters. The service abstracts the underlying communication protocols, exposing a consistent management interface. Implementation involves:

• Defining agent APIs within APIM using the new A2A API templates or import mechanisms.
• Configuring policies tailored to agent communication patterns, including authentication schemes suitable for agent identities (e.g., managed identities, certificates).
• Integrating with Azure Event Grid, Service Bus, or other messaging services if the agent APIs rely on asynchronous messaging.
• Leveraging Azure Monitor and Application Insights for telemetry collection specific to agent interactions.

Use Cases and Application Scenarios

• AI Agent Ecosystems: Managing APIs for autonomous AI agents that collaborate or compete in workflows, such as digital assistants or robotic process automation bots.
• IoT and Edge Scenarios: Governing APIs for edge agents that perform local processing and communicate with cloud services.
• Multi-agent Systems: Coordinating APIs among distributed agents in supply chain, manufacturing, or financial trading systems.
• Hybrid API Management: Combining traditional client-server APIs with agent-based APIs under a single governance model.

Important Considerations and Limitations

• As this is a public preview feature, it may have limited SLA guarantees and could undergo breaking changes before general availability.
• Some advanced agent protocols or custom communication patterns may require additional configuration or may not be fully supported initially.
• Security configurations must be carefully designed to handle agent identities and trust boundaries, especially in multi-tenant or cross-organizational scenarios.
• Performance implications should be assessed when routing high-frequency agent communications through APIM.

Integration with Related Azure Services

• Azure Event Grid and Service Bus: For asynchronous messaging patterns common in agent APIs.
• Azure Active Directory and Managed Identities: To authenticate and authorize agent identities securely.
• **Azure Monitor and Application Insights

---

This report was automatically generated - 2025-11-20 03:05:56 UTC

This site is open source. Improve this page.