azure sql database
340 Topics🔐 Public Preview: Backup Immutability for Azure SQL Database LTR Backups
The Ransomware Threat Landscape Ransomware attacks have become one of the most disruptive cybersecurity threats in recent years. These attacks typically follow a destructive pattern: Attackers gain unauthorized access to systems. They encrypt or delete critical data. They demand ransom in exchange for restoring access. Organizations without secure, tamper-proof backups are often left with no choice but to pay the ransom or suffer significant data loss. This is where immutable backups play a critical role in defense. 🛡️ What Is Backup Immutability? Backup immutability ensures that once a backup is created, it cannot be modified or deleted for a specified period. This guarantees: Protection against accidental or malicious deletion. Assurance that backups remain intact and trustworthy. Compliance with regulatory requirements for data retention and integrity. 🚀 Azure SQL Database LTR Backup Immutability (Public Preview) Microsoft has introduced backup immutability for Long-Term Retention (LTR) backups in Azure SQL Database, now available in public preview. This feature allows organizations to apply Write Once, Read Many (WORM) policies to LTR backups stored in Azure Blob Storage. Key Features: Time-based immutability: Locks backups for a defined duration (e.g., 30 days). Legal hold immutability: Retains backups indefinitely until a legal hold is explicitly removed. Tamper-proof storage: Backups cannot be deleted or altered, even by administrators. This ensures that LTR backups remain secure and recoverable, even in the event of a ransomware attack. 📜 Regulatory Requirements for Backup Immutability Many global regulations mandate immutable storage to ensure data integrity and auditability. Here are some key examples: Region Regulation Requirement USA SEC Rule 17a-4(f) Requires broker-dealers to store records in WORM-compliant systems. FINRA Mandates financial records be preserved in a non-rewriteable, non-erasable format. HIPAA Requires healthcare organizations to ensure the integrity and availability of electronic health records. EU GDPR Emphasizes data integrity and the ability to demonstrate compliance through audit trails. Global ISO 27001, PCI-DSS Require secure, tamper-proof data retention for audit and compliance purposes. Azure’s immutable storage capabilities help organizations meet these requirements by ensuring that backup data remains unchanged and verifiable. 🕒 Time-Based vs. Legal Hold Immutability ⏱️ Time-Based Immutability Locks data for a predefined period (e.g., 30 days). Ideal for routine compliance and operational recovery. Automatically expires after the retention period. 📌 Legal Hold Immutability Retains data indefinitely until the hold is explicitly removed. Used in legal investigations, audits, or regulatory inquiries. Overrides time-based policies to ensure data preservation. Both types can be applied to Azure SQL LTR backups, offering flexibility and compliance across different scenarios. 🧩 How Immutability Protects Against Ransomware Immutable backups are a critical component of a layered defense strategy: Tamper-proof: Even if attackers gain access, they cannot delete or encrypt immutable backups. Reliable recovery: Organizations can restore clean data from immutable backups without paying ransom. Compliance-ready: Meets regulatory requirements for data retention and integrity. By enabling immutability for Azure SQL LTR backups, organizations can significantly reduce the risk of data loss and ensure business continuity. ✅ Final Thoughts The public preview of backup immutability for Azure SQL Database LTR backups is a major step forward in ransomware resilience and regulatory compliance. With support for both time-based and legal hold immutability, Azure empowers organizations to: Protect critical data from tampering or deletion. Meet global compliance standards. Recover quickly and confidently from cyberattacks. Immutability is not just a feature—it’s a foundational pillar of modern data protection. Documentation is available at - Backup Immutability for Long-Term Retention Backups - Azure SQL Database | Microsoft Learn882Views4likes2CommentsStrengthening Ransomware Resilience with Immutable Backups in Azure SQL DB and Azure SQL MI
Ransomware attacks are becoming increasingly sophisticated. Attackers no longer focus only on encrypting or stealing production data. They also target backups, knowing that eliminating an organization's recovery options can turn a security incident into a prolonged business disruption. Imagine discovering that your database has been compromised, only to find that the backups you were counting on have also been deleted. Even with a comprehensive backup strategy, recovery becomes significantly more challenging when attackers can tamper with the very data needed to restore business operations. That's why backup immutability matters. We're continuing to strengthen data protection in Azure SQL Database and Azure SQL Managed Instance with a consistent set of backup immutability capabilities spanning both point-in-time restore (PITR) and long-term retention (LTR) backups. Whether you're protecting recent transactions, maintaining historical backups for years, or preserving data for regulatory requirements, Azure SQL provides multiple layers of protection to help ensure your recovery points remain available when you need them most. What makes immutable backups different? Traditional backup retention policies define how long backups should be kept. But retention alone doesn't necessarily prevent someone with sufficient privileges from deleting backups before they expire. Backup immutability adds another layer of defense. With immutability, protected backups cannot be modified, overwritten, or deleted during their immutability period, even by administrators with elevated privileges. This is particularly valuable when attackers gain access to privileged accounts. While compromised credentials may allow attackers to disrupt production environments, immutable backups help prevent them from destroying protected recovery points. Think of it as adding a safety barrier around your backups, one that helps preserve your ability to recover even when other defenses have been compromised. 1. Built-in protection for your recent backups, automatically One of the simplest ways to improve security is to make protection automatic. Azure SQL Database and Azure SQL Managed Instance now provide immutable protection for up to the most recent seven days of PITR backups by default. The best part? There's nothing you need to do to get started. No additional configuration. No separate storage accounts to manage. No immutability policies to create. No changes to existing backup and restore workflows. No additional charge for the default immutability protection. This capability is integrated directly into the Azure SQL managed backup service. For customers, that means an additional layer of protection is already working behind the scenes, helping safeguard recent recovery points against accidental deletion, malicious activity, and compromised administrative credentials. Whether you're running a business-critical application or a smaller operational database, this built-in protection provides a stronger starting point for your recovery strategy. 2. Need longer protection? Lock immutability to your PITR retention period Seven days of automatic protection is a great starting point, but every organization has different recovery requirements. Some businesses need additional time to detect security incidents, investigate suspicious activity, and determine when their data was last known to be healthy. For these scenarios, Azure SQL offers the option to extend immutable protection across the entire configured PITR backup retention period, up to 35 days where supported. For example, if your database is configured to retain 35 days of PITR backups, you can lock immutability to that retention period, protecting those recovery points against deletion or modification. Once enabled, the lock is permanent. The configured retention period can be increased, but it cannot be shortened. This provides an important safeguard against attempts to weaken backup protection, including those made using compromised administrative credentials. With this capability, organizations can align their backup protection with their recovery requirements, rather than relying solely on the default protection window. The experience is consistent across Azure SQL Database and Azure SQL Managed Instance, making it easier to establish a common data protection strategy across your Azure SQL environment. 3. Protect your long-term backups for years, not just days Recovering from a recent incident is only one part of a comprehensive data protection strategy. Many organizations also need to preserve historical backups for business continuity, regulatory compliance, internal governance, or audit requirements. Azure SQL long-term retention (LTR) supports retaining backups for up to 10 years. With LTR backup immutability, customers can go beyond simply retaining those backups and protect them against unauthorized modification or deletion. Time-based immutability allows organizations to specify how long backups must remain protected. Once immutability is enabled and locked, affected backups cannot be deleted until their retention period expires, even if an administrator later changes or removes the retention policy. Consider a financial services organization that needs to preserve database backups for seven years. By configuring locked time-based immutability, the organization can help ensure those backups remain protected throughout the required retention period. The same approach is valuable for healthcare organizations, enterprises with strict governance requirements, and businesses seeking additional safeguards against ransomware. With a consistent LTR immutability experience across Azure SQL Database and Azure SQL Managed Instance, customers can apply the same protection principles regardless of which service hosts their databases. 4. Preserve critical backups with legal holds Not every data preservation requirement has a predictable end date. An organization may need to retain a specific backup while responding to an audit, conducting an internal investigation, or addressing a legal matter. In these situations, a fixed retention period may not be sufficient. Azure SQL LTR backup immutability also supports legal holds, allowing customers to protect specific existing backups until the hold is explicitly removed. For example, if an organization needs to preserve a database backup associated with an ongoing investigation, it can apply a legal hold to prevent that backup from being deleted while the investigation continues. Legal holds can coexist with time-based immutability, providing flexibility for organizations that need both predictable retention policies and event-driven preservation requirements. This makes immutable backups valuable not only for ransomware resilience, but also for meeting evolving business and governance needs. 5. Consistent protection across Azure SQL Database and Azure SQL Managed Instance For organizations operating both Azure SQL Database and Azure SQL Managed Instance, consistency matters. Security and compliance teams shouldn't have to build entirely different backup protection strategies depending on where a database runs. With a consistent immutability experience across both services, customers can adopt a common approach to protecting recent and historical backups. Here's how the capabilities work together: Capability Customer benefit Default PITR immutability Automatic protection for up to seven days of recent backups Locked PITR immutability Extended protection aligned with configured PITR retention, up to 35 days Time-based LTR immutability Protect historical backups for their configured retention period, up to 10 years LTR legal holds Preserve selected backups until the hold is explicitly removed Together, these capabilities provide flexibility to address different recovery and retention requirements, from recovering a database to a recent point in time to preserving historical backups for years. And because the protection is integrated into Azure SQL's managed backup experience, customers don't need to build or maintain separate immutable backup storage infrastructure. 6. Building a stronger defense against ransomware Let's revisit a common ransomware scenario. An attacker gains access to a privileged account and attempts to disrupt business operations by modifying production data and deleting available backups. Without immutability, the attacker may be able to eliminate critical recovery options. With immutable backups, the story changes. Recent recovery points are protected: Default PITR immutability helps preserve backups from the most recent seven days. Extended recovery history can be safeguarded: Locked PITR immutability can protect a longer recovery window, giving organizations more options when investigating an incident. Historical backups remain protected: Locked LTR immutability helps prevent attackers from deleting backups that organizations need to retain for months or years. Critical records can be preserved: Legal holds provide additional protection for specific backups that must remain available during investigations or audits. While backup immutability doesn't prevent ransomware attacks or guarantee that every restore point is free from compromise, it makes it significantly harder for attackers to eliminate protected backups. That distinction is important. A strong ransomware recovery strategy isn't just about having backups. It's about being able to trust that your backups will still be there when you need them. Immutable backups complement other security and resilience practices, including identity protection, least-privilege access, monitoring, appropriate backup retention, and regular recovery testing. 7. Get started with immutable backups in Azure SQL Getting started is straightforward. If you're using a supported Azure SQL Database or Azure SQL Managed Instance database, you already benefit from default PITR backup immutability for up to seven days. From there, consider your organization's recovery and compliance needs: Review your PITR retention settings. Determine whether the default protection window meets your recovery objectives or whether you need a longer immutable retention period. Consider locked PITR immutability. For databases requiring extended protection, align immutability with your configured PITR retention. Evaluate your long-term backup requirements. Configure LTR immutability for backups that must remain protected for extended periods. Use legal holds when needed. Preserve specific historical backups for audits, investigations, or legal requirements. Test your recovery procedures. Validate that your organization can restore the right data when an incident occurs. Before applying permanent retention locks, carefully evaluate your requirements, because locked protection cannot be removed early. Also remember that backup immutability protects backups, not the database resource itself, so resource deletion protection and recovery planning remain important. Protecting your data. Preserving your ability to recover. As cyber threats continue to evolve, organizations need confidence not only that their data is protected, but also that they can recover when something goes wrong. With backup immutability spanning PITR and LTR backups across Azure SQL Database and Azure SQL Managed Instance, we're making it easier for customers to build stronger, more consistent data protection strategies. From automatic protection for recent backups to long-term immutable retention and legal holds, these capabilities help organizations safeguard critical recovery points, reduce ransomware-related risks, and strengthen their overall resilience. Because when the unexpected happens, the most important backup is the one you can still recover from. Learn more: PITR backup immutability for both Azure SQL DB and Azure SQL MI - Automatic backup immutability for Azure SQL Database and Azure SQL Managed Instance - Azure SQL | Microsoft Learn Azure SQL DB LTR backup immutability - Backup Immutability for Long-Term Retention Backups - Azure SQL Database | Microsoft Learn Azure SQL MI LTR backup immutability - LTR backup immutability - Azure SQL Managed Instance | Microsoft Learn My colleague SudhanshuKhera authored a comprehensive ransomware recovery plan for Azure SQL DB and Azure SQL MI - Overview: Recover Azure SQL Database and Azure SQL Managed Instance from a ransomware attack - Azure SQL Database | Microsoft Learn193Views0likes1CommentMI link support for multiple databases in an Always On availability group is now generally available
We are excited to announce the general availability of multi-database mode for MI link, which enables you to replicate multiple databases in an Always On availability group between SQL Server and Azure SQL Managed Instance through a single MI link. Managed Instance link provides near-real-time database replication between SQL Server and Azure SQL Managed Instance, helping you modernize to Azure at your own pace. Built on distributed availability group technology, MI link provides a secure and reliable connection between SQL Server and Azure SQL Managed Instance and can be used for migration, disaster recovery, and hybrid scenarios. With multi-database mode, you can extend an existing Always On availability group to Azure SQL Managed Instance and replicate all databases in that availability group through a single MI link. You can also start with standalone databases. When standalone databases are selected in SQL Server Management Studio (SSMS), the wizard creates a single-node availability group and adds the selected databases to it. With general availability, multi-database mode makes it easier to manage scenarios involving multiple databases while maintaining the flexibility and near-real-time replication provided by MI link. What’s new with general availability General availability introduces these important updates compared with the public preview: All Azure SQL Managed Instance update policies are now supported, including the SQL Server 2022 update policy, which was not supported during the public preview. You can now set up bidirectional multi-database MI link mode between SQL Server 2022 and Azure SQL Managed Instance using the SQL Server 2022 update policy. Note that SQL Server 2025 and Managed Instances using the SQL Server 2025 update policy have been supported since public preview. With SQL Server 2022 CU11 and SQL Server 2025 CU28 as a part of the general availability release, we are introducing three new stored procedures to improve supportability and troubleshooting of MI link in multi-database mode: sys.sp_milink_check - provides information about the replication health of individual databases in multi-database mode. Use this stored procedure to determine whether an individual database is stuck in seeding or replication. sys.sp_milink_reseed - restarts seeding for individual databases that are stuck in seeding in multi-database mode without requiring you to remove and re-add the database to the availability group. sys.sp_milink_repair - repairs an unhealthy replication for an individual database in multi-database mode link. Use SQL Server Management Studio (SSMS) 22.12.1 when configuring and managing MI link in multi-database mode. This version includes a number of experience improvements and bug fixes. We are also introducing better support for multiple SQL Server nodes in Always On availability groups: Multi-node availability group support in the MI link wizard (preview) enables automatic configuration of all server nodes in an Always On availability group with MI link, allowing the link to persist after an availability group failover. Instead of configuring each server node yourself, the MI link wizard can configure all server nodes for you. This SSMS feature is in preview and must be enabled by selecting Tools > Manage Preview Features in SSMS. Support for the SQL Server 2022 update policy expands the range of SQL Managed Instance environments that can take advantage of multi-database mode and provides greater flexibility when planning migrations and hybrid configurations. Multi-node availability group support in the MI link wizard (preview) eliminates the need to manually configure each server node, saving time and helping ensure that the MI link persists across local availability group failovers. How multi-database mode works With multi-database mode, MI link extends an Always On availability group between SQL Server and Azure SQL Managed Instance. A single link replicates multiple databases in the availability group to the target replica. The link uses a distributed availability group to replicate changes in near real time from the current primary replica to database copies on the secondary replica, keeping the databases synchronized. You can: Extend an existing Always On availability group to Azure SQL Managed Instance. Start with standalone SQL Server databases and let SSMS create the availability group. Add or remove databases from the availability group as your environment evolves. Fail over or cut over the availability group to Azure SQL Managed Instance when you are ready. This approach simplifies working with applications that rely on multiple databases because the databases can be managed and migrated together through a single MI link rather than through separate links for each database. Supportability Requirement Details SQL Server SQL Server 2022 with CU28 and later or SQL Server 2025 with CU11 and later. Enterprise or Developer edition. Standard edition is not supported for multi-database mode because Basic availability groups support only a single database. Azure SQL Managed Instance All service tiers, General Purpose, Next-Gen and Business Critical are supported. Use the following Azure SQL Managed Instance update policy for the following configurations: For one-way replication from SQL Server to Azure SQL Managed Instance: For one-way replication from SQL Server 2022, use Azure SQL Managed Instance with update set to SQL Server 2022, SQL Server 2025, or Always-up-to-date. For one-way replication from SQL Server 2025, use Azure SQL Managed Instance with update policy set to SQL Server 2025, or Always-up-to-date. SQL Server 2022 update policy is not supported. For two-way replication and bidirectional failover (role-reversal) between SQL Server and Azure SQL Managed Instance, the update policy must match the exact version of your SQL Server: For bidirectional replication and failover between SQL Server 2022 and Azure SQL Managed Instance, use SQL Server 2022 update policy only. Other update policies are not supported. For bidirectional replication and failover between SQL Server 2025 and Azure SQL Managed Instance, use SQL Server 2025 update policy only. Other update policies are not supported. SSMS SSMS 22.12.1 or later for the multi-database link capability. Automation Az module 16.3.0 or later and Az.Sql 7.1.0 or later, or the corresponding Azure APIs. One link for an existing multi-database availability group If you already use an Always On availability group, multi-database link mode lets you extend the complete database group to Azure SQL Managed Instance without creating a separate availability group for every database. All databases in the link move together as one managed group. Databases on the primary are read-write, while their copies on the secondary are read-only. Use of your existing Always On AG listener endpoint is supported with multi-database mode MI link, allowing the link to remain operational after a local AG failover. : A multi-database Always On availability group replicated to Azure SQL Managed Instance through one Managed Instance link. The diagram illustrates the availability group relationship rather than a specific Azure SQL Managed Instance service-tier replica count. Managed Instance link is supported across all Azure SQL Managed Instance service tiers. Run multiple links in different directions A single SQL Server instance can participate in multiple links. Each link can carry a different availability group, and supported links can replicate in different directions at the same time. In the following example, AG1 (containing DB1, DB2, and DB3) replicates from SQL Server to Azure SQL Managed Instance through MI link 1. AG2 (containing DB4, DB5, and DB6) replicates from Azure SQL Managed Instance to SQL Server through MI link 2. Both links can operate at the same time between the two instances. : Two multi-database availability groups using separate links with opposite replication directions. Important: Database names must be unique in this configuration. A database cannot be renamed on the secondary while it is participating in replication to resolve a naming conflict. Replicate one availability group to multiple managed instances Multi-database mode also supports fan-out topologies. You can replicate multiple availability groups to one managed instance, or replicate the same availability group to different managed instances. For example, separate links can target managed instances in different Azure regions. : One multi-database availability group replicated through separate links to two Azure SQL managed instances. Get started To use MI link multi-database mode, install SSMS 22.12.1 and make sure that your SQL Server and Azure SQL Managed Instance environments meet the requirements for the scenario you want to configure. To enable automatic configuration of multiple server nodes in your availability group, in SSMS select Tools > Manage Preview Features, and select "Enable multi-node availability group support in the Managed Instance link wizard." Learn more about configuring MI link with multiple databases in an Always On availability group. Share your feedback We would love to hear about your experience with multi-database mode. Please share questions, feedback, and feature suggestions through the Managed Instance link feedback form.197Views0likes0CommentsMI link support for multiple databases in an Always On availability group for SQL Server (Preview)
A simpler way to extend availability groups to Azure We are pleased to announce the preview of multi-database mode for Managed Instance link. The new mode lets you replicate multiple databases from an existing Always On availability group through a single link between SQL Server and Azure SQL Managed Instance. Update: The feature became generally available on November 17, 2026. See the multi-database mode MI link GA announcement blog post for more information. Managed Instance link uses distributed availability group technology to provide near-real-time replication between SQL Server and Azure SQL Managed Instance. It supports hybrid architectures, online migration, disaster recovery, and read-only workload offload. The link can be configured and managed through SQL Server Management Studio (SSMS), PowerShell, Azure CLI, and Azure APIs. Previously, each link supported one database. Customers with multi-database availability groups therefore had to split databases into separate availability groups and create a link for each database. Multi-database mode removes that limitation for supported SQL Server versions and editions, while the existing single-database mode remains available for earlier versions and other supported configurations. What you can do with multi-database link mode Migrate multiple databases to Azure SQL Managed Instance with minimal cutover downtime. Offload read-only workloads, including reporting and analytics, to the secondary replica. Use Azure SQL Managed Instance as a disaster recovery target for supported SQL Server versions. Start replication in either direction when the SQL Server version and Azure SQL Managed Instance update policy support that direction. Reverse primary and secondary roles through a planned failover. Build hybrid and multicloud topologies that place database groups where they are most useful. Preview requirements Requirement Details SQL Server SQL Server 2022 with CU27 and later or SQL Server 2025 with CU9 and later. Edition Enterprise or Developer edition. Standard edition is not supported for multi-database mode because Basic availability groups support only a single database. Azure SQL Managed Instance Use a compatible managed instance update policy , either SQL Server 2025, SQL Server 2022 or Always-up-to-date. Note: Managed instances with the SQL Server 2022 update policy were not supported at the initial launch of the preview. Support for these managed instances became available on November 17, 2026. SSMS SSMS 22.10.2 or later for the multi-database link capability. Update: Recommended SSMS 22.12.1 or later. Automation Az module 16.3.0 or later and Az.Sql 7.1.0 or later, or the corresponding Azure APIs. One link for an existing multi-database availability group If you already use an Always On availability group, multi-database link mode lets you extend the complete database group to Azure SQL Managed Instance without creating a separate availability group for every database. All databases in the link move together as one managed group. Databases on the primary are read-write, while their copies on the secondary are read-only. Use of your existing Always On AG listener endpoint is supported with multi-database mode MI link, allowing the link to remain operational after a local AG failover. Image 1: A multi-database Always On availability group replicated to Azure SQL Managed Instance through one Managed Instance link. The diagram illustrates the availability group relationship rather than a specific Azure SQL Managed Instance service-tier replica count. Managed Instance link is supported across all Azure SQL Managed Instance service tiers. Run multiple links in different directions A single SQL Server instance can participate in multiple links. Each link can carry a different availability group, and supported links can replicate in different directions at the same time. In the following example, AG1 (containing DB1, DB2, and DB3) replicates from SQL Server to Azure SQL Managed Instance through MI link 1. AG2 (containing DB4, DB5, and DB6) replicates from Azure SQL Managed Instance to SQL Server through MI link 2. Both links can operate at the same time between the two instances. Image 2: Two multi-database availability groups using separate links with opposite replication directions. Important: Database names must be unique in this configuration. A database cannot be renamed on the secondary while it is participating in replication to resolve a naming conflict. Replicate one availability group to multiple managed instances Multi-database mode also supports fan-out topologies. You can replicate multiple availability groups to one managed instance, or replicate the same availability group to different managed instances. For example, separate links can target managed instances in different Azure regions. Image 3: One multi-database availability group replicated through separate links to two Azure SQL managed instances. Get started To evaluate multi-database mode during preview: Confirm that the SQL Server version, edition, servicing level, and Azure SQL Managed Instance update policy meet the preview requirements. Upgrade to SSMS 22.10.2 or later, or use a supported automation interface. Enable multi-database mode before creating a multi-database link. Create the link from the existing Always On availability group and validate synchronization for every database. Review the Azure documentation for multi-database Managed Instance link configuration, limitations, monitoring, failover, and cleanup guidance. Share your feedback We would love to hear about your experience with multi-database mode. Please share questions, feedback, and feature suggestions through the Managed Instance link feedback form.550Views0likes0CommentsDatabase Hub in Microsoft Fabric is generally available: your entire database estate in one place
As applications grow, so does the database estate behind them. Many organizations now run hundreds or thousands of databases across cloud, hybrid and multicloud environments. The signals are already there: inventory, health, performance, security, risk and optimization. The hard part is making sense of them, knowing what needs attention and deciding what to do next. Today, we're announcing the general availability of Database Hub in Microsoft Fabric. Database Hub gives you one place to see your whole estate, monitor it at scale and investigate where attention is needed. It covers Azure SQL, Azure Database for PostgreSQL, Azure Cosmos DB, SQL Server and SQL database in Fabric. Everything in this release is built around that idea: one estate, every signal, wherever you work. Get started for free If you're new to Microsoft Fabric, you don't need to set anything up first. Open Database Hub, and you're automatically given a free Fabric license and taken straight to your estate. You only need Fabric capacity to share dashboards, create custom alerts or use Copilot. Generally available today Area What you get Overview A "what needs attention" view across security, performance and optimization, with the top issues and recent signal changes across SQL, PostgreSQL and Cosmos DB Estate inventory A single inventory of supported Azure and Fabric databases, with their issues and suggestions Performance monitoring Near real-time CPU, memory and storage trends, aggregated across the estate and per resource, plus normalized RU and throttled requests for Cosmos DB Security posture Findings such as public network access, missing private endpoints, Microsoft Entra authentication, audit logging and customer-managed keys Investigation The ability to drill from any finding into the affected resource, real-time dashboards and the tools you already use New in general availability: Bulk performance monitoring enablement Monitoring a large estate shouldn't mean configuring it one database at a time. You can now turn on performance monitoring at scale from the Estate view. Select multiple resources and enable performance monitoring data collection for all of them in one step. Start from your inventory. Turn on monitoring in the same place you review your databases, without switching to another portal or tool. Cover more of your estate, faster. Extend monitoring coverage across hundreds of databases without repeating setup for each one. Go from setup to insight. Once data collection is on, monitored resources show up in Performance Monitoring and real-time dashboards. New in general availability: Optimization insights Optimization now sits alongside security and performance in Overview and Estate. It highlights: Resources with a migration assessment ready License model opportunities, such as pay-as-you-go SQL Server instances that aren't reporting usage Now generally available: Real-time dashboards Real-time dashboards for Microsoft SQL, Azure Database for PostgreSQL and Azure Cosmos DB move from preview to general availability. Now generally available: VS Code and SSMS entry points DBAs work in SSMS, and developers work in VS Code. You can now open Database Hub from SSMS and from the Microsoft and MSSQL extensions for VS Code. You land in the same estate view, with the resources you were working on. SSMS VS Code Now generally available: Database Hub CLI skill Ask about estate inventory, health, performance and security posture from GitHub Copilot CLI, VS Code Copilot, Claude Code or Cursor. Get the Database Hub CLI skill from skills-for-fabric, or install it with one command: skills-for-fabric --skill databasehub-cli Then try asking, "How is my database estate doing?" or "Which databases need attention this week?" In preview Public preview: Investigate your estate with Copilot Ask questions about your databases in natural language and get answers grounded in Database Hub data. Explore trends, understand issues and suggestions, and follow up on specific resources. Try prompts such as: "What changed in my databases?" "Which resource should I investigate next?" "Which security findings should I address first?" Public preview: Database Agents Database Agents act as an extra set of eyes on your estate. An agent watches the databases you choose and stays quiet while they're healthy. When something needs your judgment, it raises an issue with supporting evidence and a recommendation. You stay in control: the agent brings the issue to you, and you decide what happens next. Start with the overall finding or select Analyze on a single query to get recommendations for that query. From there, keep investigating with Copilot or go deeper in SSMS. Database Hub is where you see the bigger picture. The database agent alerts you before your users notice. Public preview: Alerts for Azure SQL Database Create alerts from built-in templates or performance charts for one database or many. Alerts can send a Microsoft Teams message or start a Power Automate flow. They're powered by Fabric Activator. Preview: Performance monitoring for SQL Server on Azure VMs Review SQL Server on Azure Virtual Machines in the same Performance Monitoring experience as the rest of your estate. What's next More skills are on the way, including SQL performance monitoring, Cosmos DB performance monitoring and migration skills. Get started today Open Database Hub: https://app.fabric.microsoft.com/workloads/fdh/databaseHub/overview Learn more: https://learn.microsoft.com/en-us/fabric/database/hub Install the Database Hub CLI skill: https://github.com/microsoft/skills-for-fabric/tree/main/skills/databasehub-cli Read more about Database Hub Database Hub in Fabric: Now in Public Preview -Turn Database Signals into Guided Action | Microsoft Community Hub Public Preview: Performance monitoring for Azure SQL in Database Hub | Microsoft Community Hub A Single View of Your PostgreSQL Estate: Database Hub in Public Preview | Microsoft Community Hub Make Estate yours: Focus on the databases and issues you own in Database Hub | Microsoft Community Hub Public Preview: Alerts for Azure SQL Database in Database Hub, powered by Fabric Activator | Microsoft Community Hub Managing security with Database Hub in Fabric: From signals to action | Microsoft Community Hub Database watcher for Azure SQL is retiring: simplify your monitoring with Database Hub | Microsoft Community Hub Ask your database estate a question: Copilot in Database Hub is now in public preview | Microsoft Community Hub440Views3likes2CommentsFuzzy string matching is now generally available across Microsoft SQL
Four native T-SQL functions that tell you how close two strings are, not just whether they’re equal. MICROSFT isn’t MICROSOFT. MARHTA isn’t MARTHA. INV-1O08 isn’t INV-1008. To an equality check, each pair is simply different. To your business, each is a near miss worth catching. Today, fuzzy string matching is generally available in Microsoft SQL. EDIT_DISTANCE tells you MICROSFT is one edit from MICROSOFT. JARO_WINKLER_SIMILARITY scores MARTHA and MARHTA at 96 out of 100. It all runs in T-SQL, right where your data lives, with no external libraries, models, or custom code. Available across all SKUs of: Azure SQL Database Azure SQL Managed Instance SQL database in Microsoft Fabric SQL Server 2025, starting with Cumulative Update 11 (CU11), and later cumulative updates What fuzzy string matching actually means Fuzzy string matching measures how closely two strings resemble each other without requiring an exact match. Think of it as comparing the written form of two values. An exact comparison asks, “Are these equal under our comparison rules?” Fuzzy matching adds, “If not, how close are they?” For an edit-distance algorithm, closeness can be measured by the operations needed to transform one string into the other: FORM swap O and R FROM One adjacent swap makes the strings identical. Insertion, deletion, substitution, and transposition are transformation operations, not assumptions about what originally caused the difference. This is useful for typo-tolerant lookup, candidate duplicate detection, master-data reconciliation, and reviewing text captured by optical character recognition (OCR). It is not the same as understanding meaning. car and automobile are related concepts but have very different character sequences. Nor does a high similarity score establish that two records represent the same person, product, or organization. Fuzzy matching provides evidence for a decision, not the decision itself. Meet the four functions The feature provides two algorithm families, each exposed through a distance function and a similarity function. Function Algorithm Return type How to read the result EDIT_DISTANCE Damerau-Levenshtein (Optimal String Alignment) int Edit count, or an over-budget marker when limited; lower means closer EDIT_DISTANCE_SIMILARITY Damerau-Levenshtein (Optimal String Alignment) int Normalized score from 0 to 100; higher means closer JARO_WINKLER_DISTANCE Jaro-Winkler float Distance from 0 to 1; lower means closer JARO_WINKLER_SIMILARITY Jaro-Winkler int Score from 0 to 100; higher means closer Their signatures are: EDIT_DISTANCE ( character_expression , character_expression [ , maximum_distance ] ) EDIT_DISTANCE_SIMILARITY ( character_expression , character_expression ) JARO_WINKLER_DISTANCE ( character_expression , character_expression ) JARO_WINKLER_SIMILARITY ( character_expression , character_expression ) The inputs can be constants, variables, or columns. Use bounded character types such as varchar(n) or nvarchar(n); varchar(max) and nvarchar(max) are not supported. If an input is NULL, the result is NULL. A first comparison Each example is self-contained, creates no permanent objects, and applies a supported collation (Latin1_General_100_CI_AS_SC) with COLLATE, so you can run it without changing your database collation. ;WITH Pair AS ( SELECT N'Colour' COLLATE Latin1_General_100_CI_AS_SC AS SourceText, N'Color' COLLATE Latin1_General_100_CI_AS_SC AS TargetText ) SELECT SourceText, TargetText, EDIT_DISTANCE(SourceText, TargetText) AS Edits, EDIT_DISTANCE_SIMILARITY(SourceText, TargetText) AS EditScore, JARO_WINKLER_DISTANCE(SourceText, TargetText) AS JwDistance, JARO_WINKLER_SIMILARITY(SourceText, TargetText) AS JwScore FROM Pair; The query returns: Edits EditScore JwDistance, approximately JwScore 1 83 0.033333 97 One deletion removes the u. Both algorithm families recognize a close match, but they express closeness differently. A Jaro-Winkler distance of approximately 0.033333 is not a fractional number of edits. Damerau-Levenshtein (Optimal String Alignment): how many edits? EDIT_DISTANCE and EDIT_DISTANCE_SIMILARITY implement Damerau-Levenshtein (Optimal String Alignment, or OSA), the restricted Damerau-Levenshtein variant. Each permitted operation has a cost of one: Operation Example What changes Insertion CT to CAT Insert A Deletion CART to CAT Delete R Substitution CAT to CUT Replace A with U Adjacent transposition FORM to FROM Swap O and R The distance is the minimum cost of a transformation allowed by this algorithm, so each pair above has a distance of 1. Why “Optimal String Alignment” matters The qualification is important: this is not unrestricted Damerau-Levenshtein. In the Optimal String Alignment variant, the same substring cannot be edited more than once along the transformation. For example, unrestricted Damerau-Levenshtein can transform CA into ABC in two operations: CA -> AC -> ABC swap insert B That sequence re-edits the transposed region. The restricted Damerau-Levenshtein (Optimal String Alignment) algorithm does not allow that transformation path, and the distance is 3, not 2. SELECT EDIT_DISTANCE( N'CA' COLLATE Latin1_General_100_CI_AS_SC, N'ABC' COLLATE Latin1_General_100_CI_AS_SC ) AS Edits; -- Result: 3 For everyday typos this rarely matters, but it does when you compare results with another library or migrate an existing matching implementation. From edit count to similarity An absolute edit count does not tell the whole story. Removing one character from a four-character value changes a larger proportion of the string than removing one character from a six-character value. EDIT_DISTANCE_SIMILARITY normalizes edit distance using the longer input: (1 - (edit_distance / greatest(len(string1), len(string2)))) * 100 For example: CART and CAT: (1 - 1/4) * 100 = 75. Colour and Color: (1 - 1/6) * 100 is approximately 83.33; the function returns the integer 83. A score of 83 measures resemblance; it is not an 83% probability that the values refer to the same thing. Jaro-Winkler: a different way to rank resemblance Sometimes the question is not “How many edits are allowed?” but “Which names are the most plausible matches?” Jaro-Winkler considers matching characters within a positional matching window: a character must occur close enough to its position in the other string to count as a match. It also considers the relative order of those matches, then gives additional weight to a shared prefix. It does not calculate the minimum number of operations needed to transform one string into another. Consider MARTHA and MARHTA. They share the same characters, with T and H out of order, and both start with MAR. ;WITH Names AS ( SELECT NameA COLLATE Latin1_General_100_CI_AS_SC AS NameA, NameB COLLATE Latin1_General_100_CI_AS_SC AS NameB FROM (VALUES (N'MARTHA', N'MARHTA'), (N'CONTOSO HEALTH', N'CONTOSO RETAIL') ) AS n(NameA, NameB) ) SELECT NameA, NameB, EDIT_DISTANCE(NameA, NameB) AS Edits, JARO_WINKLER_DISTANCE(NameA, NameB) AS JwDistance, JARO_WINKLER_SIMILARITY(NameA, NameB) AS JwScore FROM Names ORDER BY JwScore DESC, NameA, NameB; NameA NameB Edits JwDistance, approximately JwScore MARTHA MARHTA 1 0.038889 96 CONTOSO HEALTH CONTOSO RETAIL 5 0.082143 92 Jaro-Winkler is worth evaluating for person and organization names when shared beginnings are meaningful and usually entered correctly. But prefixes can mislead: CONTOSO HEALTH and CONTOSO RETAIL score 92 despite five edits and may be different organizations. The prefix length and scaling factor are fixed; the functions don’t expose parameters for them. Choose Damerau-Levenshtein (OSA) for an explicit edit budget. Evaluate Jaro-Winkler for ranking character-based resemblance when prefix preference fits your data. Use maximum_distance when you only need a threshold Suppose your application accepts candidates within two edits. An exact distance of eight is unnecessary if all you need to know is that the candidate exceeds the budget. The optional maximum_distance argument lets EDIT_DISTANCE stop early once the distance exceeds the threshold. Within the threshold, it returns the actual distance; beyond it, it returns maximum_distance + 1. ;WITH Pairs AS ( SELECT SourceText COLLATE Latin1_General_100_CI_AS_SC AS SourceText, TargetText COLLATE Latin1_General_100_CI_AS_SC AS TargetText FROM (VALUES (N'CART', N'CAT'), (N'FORM', N'FROM'), (N'Chocolate', N'Sweets'), (N'CAT', N'CAT') ) AS p(SourceText, TargetText) ) SELECT SourceText, TargetText, EDIT_DISTANCE(SourceText, TargetText) AS ActualDistance, EDIT_DISTANCE(SourceText, TargetText, 2) AS BoundedDistance FROM Pairs ORDER BY SourceText; Pair ActualDistance BoundedDistance CART / CAT 1 1 CAT / CAT 0 0 Chocolate / Sweets 8 3 FORM / FROM 1 1 The value 3 for Chocolate / Sweets means “over the budget of two”, not “exactly three edits.” Use the bounded form to accept or reject candidates, not to rank how far apart rejected values are. Put it to work: typo-tolerant lookup Let’s return to MICROSFT. We want a short list of catalog values no more than one edit away. DECLARE @query nvarchar(40) = N'MICROSFT'; ;WITH Catalog AS ( SELECT Name COLLATE Latin1_General_100_CI_AS_SC AS Name FROM (VALUES (N'MICROSFT'), (N'MICROSOFT'), (N'CONTOSO') ) AS c(Name) ) SELECT Name, EDIT_DISTANCE( Name, @query COLLATE Latin1_General_100_CI_AS_SC ) AS Distance FROM Catalog WHERE EDIT_DISTANCE( Name, @query COLLATE Latin1_General_100_CI_AS_SC, 1 ) <= 1 ORDER BY Distance, Name; The result contains MICROSFT with distance 0, followed by MICROSOFT with distance 1; CONTOSO is outside the budget. The misspelled catalog entry is included deliberately: exact matches rank first, and the application can offer the alternatives instead of silently rewriting the input. The bounded call filters, while the unbounded call supplies the ranking value. Find candidate duplicates without comparing everyone to everyone Customer deduplication needs both textual resemblance and business context. Comparing every customer with every other customer produces a number of pairs that grows approximately with the square of the row count. A practical first step is blocking: group records using a trusted attribute, then compare names within those groups. ;WITH Customer AS ( SELECT CustomerId, Name COLLATE Latin1_General_100_CI_AS_SC AS Name, PostalCode FROM (VALUES (1, N'MARTHA', N'98052'), (2, N'MARHTA', N'98052'), (3, N'MARTHA', N'10001'), (4, N'ROBERT', N'98052') ) AS c(CustomerId, Name, PostalCode) ) SELECT a.CustomerId AS CustomerA, b.CustomerId AS CustomerB, a.Name AS NameA, b.Name AS NameB, JARO_WINKLER_SIMILARITY(a.Name, b.Name) AS Score FROM Customer AS a JOIN Customer AS b ON a.PostalCode = b.PostalCode AND a.CustomerId < b.CustomerId WHERE JARO_WINKLER_SIMILARITY(a.Name, b.Name) >= 92 ORDER BY Score DESC, CustomerA, CustomerB; Three details make the query useful: Postal-code equality creates the shortlist. Only customers within the same postal code are compared. a.CustomerId < b.CustomerId emits each pair once. It excludes self-comparisons and reversed duplicates such as (2,1) when (1,2) already exists. The similarity filter flags plausible names. MARTHA and MARHTA pass the illustrative cutoff; pairs involving ROBERT do not. The query returns one pair: customer 1 and customer 2, with a similarity score of 96. The other MARTHA, in postal code 10001, is not compared with the 98052 group. That illustrates the trade-off: blocking reduces comparisons but can miss true duplicates when the blocking attribute differs or is wrong. The cutoff of 92 is only illustrative: CONTOSO HEALTH and CONTOSO RETAIL also scored 92 earlier. Confirm candidates with independent evidence, such as a verified email or phone number. Reconcile OCR mistakes within the right business context An invoice reader captures INV-1O08, confusing the letter O with the digit 0. Comparing against every invoice would be risky. Start with the vendor, then allow one character edit: ;WITH Captured AS ( SELECT 10 AS VendorId, N'INV-1O08' COLLATE Latin1_General_100_CI_AS_SC AS Invoice ), ReferenceInvoice AS ( SELECT VendorId, Invoice COLLATE Latin1_General_100_CI_AS_SC AS Invoice FROM (VALUES (10, N'INV-1008'), (10, N'INV-1208'), (20, N'INV-1008') ) AS r(VendorId, Invoice) ) SELECT c.VendorId, c.Invoice AS CapturedInvoice, r.Invoice AS CandidateInvoice, EDIT_DISTANCE(c.Invoice, r.Invoice) AS Edits FROM Captured AS c JOIN ReferenceInvoice AS r ON c.VendorId = r.VendorId WHERE EDIT_DISTANCE(c.Invoice, r.Invoice, 1) <= 1 ORDER BY c.VendorId, r.Invoice; The query returns two candidates for vendor 10: Candidate invoice Transformation Edits INV-1008 Replace O with 0 1 INV-1208 Replace O with 2 1 Vendor 20’s invoice is excluded by the vendor condition. Within vendor 10, both substitutions cost one edit; the function doesn’t know that OCR often confuses O and 0. Attributes such as amount and date must decide which invoice was intended. Useful with AI, without being an AI model These functions require no embeddings, model training, or inference endpoint. They also fit naturally into AI-assisted workflows. For example, a language model might extract CONTOS from a document. The application can use fuzzy matching to shortlist names in its organization directory. The same SQL works if the input came from a person or a batch import instead. DECLARE @entity nvarchar(100) = N'CONTOS'; ;WITH Organization AS ( SELECT OrganizationId, Name COLLATE Latin1_General_100_CI_AS_SC AS Name, CountryCode FROM (VALUES (1, N'CONTOSO', N'US'), (2, N'CONTOSO HEALTH', N'US'), (3, N'CONTOSO RETAIL', N'US'), (4, N'CONTOSO', N'GB') ) AS o(OrganizationId, Name, CountryCode) ) SELECT TOP (5) OrganizationId, Name, JARO_WINKLER_SIMILARITY( Name, @entity COLLATE Latin1_General_100_CI_AS_SC ) AS Score FROM Organization WHERE CountryCode = N'US' AND JARO_WINKLER_SIMILARITY( Name, @entity COLLATE Latin1_General_100_CI_AS_SC ) >= 80 ORDER BY Score DESC, OrganizationId; The query returns three US candidates: CONTOSO with a score of 97, followed by CONTOSO HEALTH and CONTOSO RETAIL at 89 each. The GB record is excluded. Change @entity to N'ZZZZ' and the query returns no rows; the application should treat that as “no match” rather than force a best guess. Fuzzy matching won’t expand an acronym into a company name or resolve related meanings. Use an alias table or a semantic approach for those tasks. Where this fits in the SQL matching toolbox Fuzzy string matching extends existing capabilities; it does not replace them. Question Appropriate tool Example Are these values equal under the intended comparison rules? Equality, joins, and an appropriate collation Match a trusted customer key Does the text contain a known pattern or substring? LIKE, CHARINDEX, PATINDEX Find a known prefix Does the text follow a structured pattern? REGEXP_* functions Validate or extract a formatted value Do these values have similar phonetic representations? SOUNDEX, DIFFERENCE Coarse screening of English-oriented names How far apart are these values in character edits? EDIT_DISTANCE, EDIT_DISTANCE_SIMILARITY Measure edit count or normalized edit similarity How similar are character alignment and prefixes? JARO_WINKLER_DISTANCE, JARO_WINKLER_SIMILARITY Rank plausible name matches Which documents contain relevant words or phrases? Full-text search Linguistic document retrieval Which representations are close in embedding space? Vector similarity/search Semantic retrieval for AI applications For example, SOUNDEX('Robert') and SOUNDEX('Rupert') both return R163: a phonetic signal, which is different from the character-similarity scores announced here. Good to know Collation: The functions support Windows collations and binary (BIN, BIN2) collations. Non-binary SQL_* collations, such as the common default SQL_Latin1_General_CP1_CI_AS, are not supported. Apply COLLATE to the inputs, as the examples do; you don’t need to change the database collation. Scale: Narrow the candidate set with trusted business keys, such as region, vendor, or category, before scoring. Scores: Test thresholds on your own labeled examples. A score is evidence of a possible match, not proof. Get started Azure SQL Database and SQL database in Microsoft Fabric: The functions are available now. Azure SQL Managed Instance: Use the SQL Server 2025 or Always-up-to-date update policy. SQL Server 2025: Install CU11 or later. If you tried the functions in preview, you no longer need the PREVIEW_FEATURES database scoped configuration to use them. Pick a column you already struggle to match, try the examples above on your own data, and see what turns up. Whether you’re cleaning customer records, forgiving a typo in a search box, or grounding an AI-extracted name, fuzzy string matching is now a native part of T-SQL, ready wherever your data lives. We’d love to hear what you build with it. Learn more Fuzzy string matching overview EDIT_DISTANCE reference EDIT_DISTANCE_SIMILARITY reference JARO_WINKLER_DISTANCE reference JARO_WINKLER_SIMILARITY reference98Views0likes0CommentsTake control of transparent data encryption scans: suspend and resume now in preview
Suspend and resume for transparent data encryption (TDE) scans in Azure SQL Database lets you temporarily halt an encryption scan during busy periods and continue it later from the exact point where it stopped, instead of starting over. Why we built it TDE protects your databases, backups, and transaction log files at rest, without any changes to your application. When you turn encryption on or off, the service runs an encryption scan across the database. The scan duration is proportional to the size of the database, and for large databases it can take a long time. While it runs, the scan consumes CPU and I/O, which can affect user workloads during peak hours. Until now, scans were all or nothing: once started, a scan had to complete. What is new Suspend and resume gives database administrators and owners control over the encryption scan: Suspend temporarily halts the encryption scan on the data and log files and releases the resources it was using. Resume restarts the scan from the point of suspension. While a scan is suspended, new or updated data pages continue to be handled according to the direction of the scan. If you were encrypting, new pages are still encrypted. If you were decrypting, new pages are written unencrypted. You can also toggle direction while a scan is suspended. For example, you can start encryption, suspend it, and then turn encryption off. The decryption scan starts from the beginning. The same applies in reverse. This works for TDE with service-managed keys and with customer-managed keys. Manage encryption status in the Azure portal You can see and control the state of the encryption scan directly in the Azure portal. On the transparent data encryption page of your database, the encryption status shows whether the database is encrypted, being encrypted, or suspended, and offers the matching action. Encryption in progress While the scan is running, the status shows that encryption is in progress and a suspend button appears to pause the scan. Suspended When you suspend the scan, the status changes to suspended and a resume button appears so you can continue from where you left off. Encrypted Once the scan completes, the database shows as encrypted. Use T-SQL to suspend and resume The same commands that exist in SQL Server are available in Azure SQL Database. Suspend an encryption scan ALTER DATABASE my_db_name SET ENCRYPTION SUSPEND Resume a suspended encryption scan ALTER DATABASE my_db_name SET ENCRYPTION RESUME Start encryption, suspend it, then decrypt again ALTER DATABASE my_db_name SET ENCRYPTION ON ALTER DATABASE my_db_name SET ENCRYPTION SUSPEND ALTER DATABASE my_db_name SET ENCRYPTION OFF Monitor the scan Track the state of the scan with the sys.dm_database_encryption_keys dynamic management view, which reports the encryption state of the database and its encryption keys. SELECT DB_NAME(database_id), * FROM sys.dm_database_encryption_keys The percent_complete column shows the progress of the encryption state change. Get started and share feedback Suspend and resume is available in public preview for Azure SQL Database. Public preview features are covered by the Supplemental Terms of Use for Microsoft Azure Previews. To learn more about how TDE works, including service-managed and customer-managed keys, see the TDE overview on Microsoft Learn. Try it on your databases and tell us what you think. Your feedback helps us shape the feature before general availability.113Views0likes0CommentsTransparent data encryption in Azure SQL Database now supports AES keys (Generally Available)
TDE with customer-managed keys has traditionally used asymmetric RSA-based key protectors, while broader industry guidance is increasingly focused on preparing for a post-quantum cryptographic (PQC) future and adopting cryptographic approaches that are better aligned with that transition. This update aligns with broader security guidance, including the NSA’s CNSA 2.0 recommendations, which emphasize modern cryptographic planning for a quantum-resistant future. For organizations building crypto agility into their platforms, AES key support is a practical step in that direction. Why it matters Preparing for a post‑quantum world With current technology, breaking asymmetric algorithms such as Elliptic Curve and RSA-2048 using the best-known classical methods would take billions of years. Even with large-scale distributed computing, it is still considered computationally infeasible. Asymmetric algorithms are vulnerable to Shor’s algorithm, which means a sufficiently powerful quantum computer could break RSA-2048 much faster. That said, this would require millions of stable qubits, and current quantum systems are still far from that point. AES, as a symmetric algorithm, is not affected by Shor’s algorithm and remains more resistant to known quantum attacks, including Grover’s algorithm, when used with larger key sizes such as AES-256. The figure below highlights the difference in the estimated effort required to break RSA-2048 and AES-256. For context, the green dashed line represents the age of the universe, about 13.8 billion years. Aligning with modern security guidance Security guidance is moving toward stronger crypto agility and long-term resilience. By supporting AES keys for TDE protectors, Azure SQL Database gives customers a way to align data-at-rest protection with evolving security and compliance expectations. For a broader overview of quantum computing and cryptography, see Microsoft’s post-quantum cryptography overview. How it works (high level) At a high level, nothing changes about the purpose of TDE: it still protects data at rest by encrypting the Database Encryption Key (DEK) with a TDE protector. What changes is the type of key you can use to protect, or wrap, the AES DEK. The AES DEK encrypts database data files and log files. The TDE protector encrypts the DEK. With TDE with customer‑managed keys, the TDE protector is stored in Azure Key Vault or Azure Key Vault Managed HSM. The TDE protector can now be a symmetric AES key instead of an RSA key. For background on customer-managed TDE, see the Customer-managed transparent data encryption (TDE) Get started Make sure the following prerequisites are in place: An Azure SQL Database logical server or database with customer-managed TDE enabled. An Azure Key Vault Premium or Azure Key Vault Managed HSM with support for AES keys. Soft-delete and purge protection enabled on the key store. The required permissions for Azure SQL Database to access the key. You can review the full prerequisites in Microsoft Learn under requirements to configure customer-managed TDE. The setup flow for AES keys is essentially the same as for RSA-based TDE protectors. The main difference is the type of key you create and register. Create an AES key (for example, AES‑256) in Azure Key Vault Premium. Add the key to your Azure SQL logical server. Set the AES key as the TDE protector. Verify that encryption is enabled using system views. For step-by-step configuration guidance, see Microsoft Learn on Create Azure SQL Database Logical Server Configured with User-Assigned Managed Identity and Customer-Managed TDE. Example configuration (PowerShell) The following example shows the basic PowerShell flow: create an AES key, register it with the logical server, and then set it as the TDE protector. # Variables $VaultName = "MyPremiumVault" $keyName = "TDE-AES-Key" $sqlServerName = "my-sql-server" $sqlResourceGroup = "my-sql-rg" # Create an AES-256 HSM-backed key in MHSM Add-AzKeyVaultKey ` -VaultName $VaultName ` -Name $keyName ` -KeyType oct ` -Destination HSM ` -Size 256 # Get key URI $key = Get-AzKeyVaultKey -VaultName $VaultName -Name $keyName # Register the key with the SQL server Add-AzSqlServerKeyVaultKey ` -ResourceGroupName $sqlResourceGroup ` -ServerName $sqlServerName ` -KeyId $key.Id # Set the key as the TDE protector Set-AzSqlServerTransparentDataEncryptionProtector ` -ResourceGroupName $sqlResourceGroup ` -ServerName $sqlServerName ` -Type AzureKeyVault ` -KeyId $key.Id After you enable TDE with AES keys, you can verify the database encryption status by running the following query: SELECT DB_NAME(database_id) AS DatabaseName, encryption_state_desc, encryptor_type FROM sys.dm_database_encryption_keys WHERE database_id <> 2; If the database is encrypted, the view returns an ENCRYPTED state, or ENCRYPTION_IN_PROGRESS while encryption is still underway, with SYMMETRIC_KEY shown as the encryptor type. Learn more Microsoft Learn: customer-managed transparent data encryption for Azure SQL Database Microsoft Learn: configure customer-managed TDE for Azure SQL Database Microsoft Research: post-quantum cryptography overview Conclusion AES key support for customer-managed TDE gives Azure SQL Database customers a practical way to strengthen their encryption strategy while preparing for long-term cryptographic change, including post quantum cryptography. Because the setup experience remains familiar, teams can use this new functionality without rethinking how TDE works operationally.947Views3likes0CommentsAzure SQL Hyperscale Cross-database querying: now in limited preview
Azure SQL Database Hyperscale now supports cross-database queries in limited preview. Use familiar [database].[schema].[object] names to query across databases in the same Hyperscale elastic pool from a single connection, with no external tables or extra network setup. It's built to simplify migrations of SQL Server apps that rely on cross-database queries, and to replace app-side joins and duplicated data. Sign up at aka.ms/azuresql-crossdb-prpr.356Views0likes0CommentsZone-Redundant Next-Gen General Purpose for Azure SQL Managed Instance
Customers no longer need to choose between the latest General Purpose architecture and zone-level resiliency. With the general availability of zone redundancy for Next-Generation General Purpose Azure SQL Managed Instance, organizations can now take advantage of all the benefits of Next-Generation General Purpose while meeting strict high availability and compliance requirements through Availability Zone protection. When Next-Generation General Purpose became generally available, it introduced a modernized General Purpose architecture delivering improved performance, greater scalability, enhanced flexibility, and better price-performance for Azure SQL Managed Instance workloads. Since then, customers have increasingly adopted the architecture to modernize SQL workloads, consolidate databases, and optimize total cost of ownership. Today, we're extending those benefits to customers who require zone-level resiliency. With zone redundancy now generally available, customers can realize all the advantages of Next-Generation General Purpose while meeting the same zone-level availability requirements previously available only with Classic General Purpose. This milestone brings full high-availability parity between Classic General Purpose and Next-Generation General Purpose, removing one of the last major reasons for customers to remain on the previous architecture. Closing the last major gap Zone redundancy has consistently been one of the most requested capabilities for Next-Generation General Purpose. Since its introduction, Next-Generation General Purpose has provided substantial improvements in scalability and flexibility, including support for up to 128 vCores, up to 32 TB of storage, up to 500 databases per instance, configurable IOPS, and flexible memory sizing. Customers can optimize resources for their workload requirements while continuing to benefit from the simplicity and compatibility of Azure SQL Managed Instance. With today's announcement, these capabilities can now be combined with zone-level resiliency, enabling customers to deploy highly available business-critical workloads on the latest General Purpose architecture without compromise. In addition, the flexible memory option for zone-redundant Next-Generation General Purpose instances is also generally available, providing even greater flexibility to balance performance requirements and infrastructure costs. Built-in high availability, now with Zone-level protection Azure SQL Managed Instance has always been designed for high availability. Next-Generation General Purpose delivers built-in high availability through its distributed architecture, leveraging Service Fabric together with fault domains and update domains to minimize the impact of hardware failures, software updates, and planned maintenance events. This architecture enables applications to remain available even during infrastructure events and maintenance operations. As a result, single-zone deployments provide a 99.99% availability SLA. For organizations with more demanding availability requirements, zone redundancy distributes service components across multiple Availability Zones within a region. This provides protection against zone-level failures and increases the availability SLA to 99.995%. While many workloads are well served by single-zone deployments, organizations in regulated industries and mission-critical environments often require zone-redundant architectures as part of compliance, operational resilience, or business continuity requirements. These customers can now adopt Next-Generation General Purpose without sacrificing those requirements. Regional availability Zone redundancy for Next-Generation General Purpose is generally available in all regions where the underlying ESAN infrastructure supports zone-redundant deployments. For the latest list of supported regions, check out the documentation page containing the regions where Elastic SAN is currently available and the supported redundancy options. Regions that do not yet support ESAN-based zone redundancy are not supported at this time. Additional regions will become available as platform support expands. Upgrading existing deployments Whether you are already running Next-Generation General Purpose or remain on Classic General Purpose, adopting zone-redundant Next-Generation General Purpose is designed to be straightforward and transparent. Enable zone redundancy on existing Next-gen General Purpose instances Customers already running Next-Generation General Purpose can enable zone redundancy directly on existing instances and immediately benefit from enhanced resiliency and a higher availability SLA. Move from classic General Purpose zone-redundant to Next-generation General Purpose zone-redundant Customers currently running Classic General Purpose with zone redundancy can migrate to Next-Generation General Purpose while preserving zone-level resiliency and gaining access to the latest platform architecture, resource flexibility, and scalability improvements. This provides a natural modernization path for existing deployments and allows customers to standardize on the future architecture of the General Purpose tier. Online operation with a short failover Enabling zone redundancy or migrating between architectures is performed as an online management operation. During most of the operation, Azure SQL Managed Instance provisions and synchronizes the new infrastructure while the existing deployment continues serving application traffic. Near the end of the operation, a brief failover occurs as client connections are switched from the existing infrastructure to the newly provisioned environment. For more information about management operations, expected behavior, and application connectivity considerations, see management operations overview article. Protecting workloads beyond a single region For customers running in regions where zone redundancy is not currently available, or for customers seeking protection from broader regional outages, Failover Groups remain the recommended solution. Failover Groups enable disaster recovery across Azure regions by maintaining a secondary managed instance and providing automatic or manual failover capabilities when needed. This approach helps organizations meet business continuity objectives even when Availability Zone protection is unavailable or when protection from regional outages is required. Optimize disaster recovery costs with License Free failover rights Customers implementing disaster recovery through Failover Groups can further optimize costs through Azure SQL License Free failover rights. When the secondary managed instance is maintained exclusively for standby disaster recovery purposes and is not used for read-only workloads, SQL Server licensing costs do not apply to the secondary environment. Customers pay only for the compute resources required to maintain disaster recovery readiness, helping reduce overall total cost of ownership. Planning costs The Azure SQL Managed Instance pricing page and Azure Pricing Calculator have been updated to include the latest zone-redundant Next-Generation General Purpose offerings. These tools can help customers evaluate deployment options, compare availability architectures, and estimate costs associated with zone redundancy and disaster recovery configurations. Get started Zone redundancy for Next-Generation General Purpose marks the completion of an important milestone in the evolution of Azure SQL Managed Instance. Customers can now combine the performance, scalability, flexibility, and operational advantages of Next-Generation General Purpose with zone-level resiliency and a 99.995% availability SLA. Whether deploying new workloads, enabling zone redundancy on existing Next-Generation General Purpose instances, or modernizing Classic General Purpose deployments, organizations now have a clear path to adopting the latest General Purpose architecture without compromise. Try Azure SQL Managed Instance for free Learn more What is Azure SQL Managed Instance Availability through local and zone redundancy - Azure SQL Managed Instance Flexible memory - Azure SQL Managed Instance Next-gen General Purpose – official documentation Accelerate SQL Server Migration to Azure with Azure Arc Analyzing the Economic Benefits of Microsoft Azure SQL Managed Instance How 3 customers are driving change with migration to Azure SQL948Views1like0Comments