Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
Azure HorizonDB is a cloud-native, fully managed, AI-ready database service built on PostgreSQL. It combines a disaggregated compute and storage architecture with a database-as-a-log design to deliver predictable performance, enterprise-grade security, high availability, and seamless scalability for mission-critical workloads.
Azure HorizonDB empowers developers to build intelligent, AI-powered applications through native support for vector embeddings and integration with Microsoft Foundry, while retaining full PostgreSQL compatibility so existing applications can easily migrate to Azure HorizonDB.
Azure HorizonDB use cases
Azure HorizonDB is a cloud-native, scalable alternative to self-managed PostgreSQL and is designed for mission-critical workloads, including:
- Transactional workloads (OLTP) - High-throughput, low-latency transaction processing with predictable performance for line-of-business applications, e-commerce platforms, and SaaS backends.
- AI and intelligent applications - Native vector search and embedding support lets you build retrieval-augmented generation (RAG) pipelines, recommendation engines, and semantic search directly within the database layer. AI model management and AI pipelines further simplify building intelligent applications within the database.
- Massive read scale-out - Applications that can benefit from read scale-out with shared zone resilient data.
- Hybrid applications - Integration with the Azure ecosystem. Mirror transactional data to Microsoft Fabric OneLake and combine it with other analytical data.
Architecture of Azure HorizonDB
Azure HorizonDB is built on two foundational architectural principles: separation of compute and storage, and a database-as-a-log design.
Disaggregated compute and storage
The architecture fully separates the compute layer from the storage layer:
- Compute layer - Compute on Azure HorizonDB is stateless. You can scale compute resources (vCores and memory) independently without affecting storage, and vice versa. You can scale out reads by adding reader nodes.
- Storage layer - The storage layer uses two purpose-built storage fleets: one dedicated for WAL, and another for data; both have durability backed by Azure storage. All storage is zone-resilient by default. Storage scales automatically as data grows, independent of compute.
The separation of compute and storage provides several benefits:
- Scale compute and storage independently based on workload demands.
- Quickly provision reader nodes, because all nodes share the same storage and no data copy is needed.
- Faster failover, because WAL storage is shared and durable, and no log rewinding is needed.
Database-as-a-log architecture
Azure HorizonDB adopts the database-as-a-log architecture where only the write-ahead log (WAL) is written from compute to the storage layer. Data pages aren't written from the compute nodes to the storage layer. WAL is the authoritative source of truth throughout the system.
- All writes (Write ahead Log) are appended to a durable log service before being acknowledged to the client. The WAL Service is optimized for semantics of a transaction log and optimized for low latency.
- Filtered WAL is sent to only the storage nodes that the changes belong to.
- Storage nodes reconstruct page state by applying the WAL, eliminating traditional checkpoint I/O bottlenecks.
- This approach reduces write amplification and delivers consistent, predictable write latency regardless of database size.
The combination of these two principles enables Azure HorizonDB to deliver high throughput, low latency, and efficient resource utilization while maintaining full ACID guarantees.
Azure HorizonDB cluster
The Azure HorizonDB resource that you create and manage is called a cluster. A cluster is the unit that you connect to, secure, back up, and restore. Each cluster brings together two building blocks:
- Compute - Servers called nodes run PostgreSQL and process your queries. Nodes are organized into groups called compute pools. Your applications connect to endpoints, which route each connection to the right node.
- Storage - All nodes in the cluster share a single copy of your data.
You secure and configure the cluster, and you size and scale its compute pools. Azure HorizonDB creates, places, and maintains the nodes for you.
The architecture diagram earlier in this article shows how these building blocks fit together. The following table summarizes what a cluster contains.
| Component | Description | Number per cluster |
|---|---|---|
| Writer node | Processes all writes. It can also process reads. | One |
| Reader node | Processes reads. If the writer node fails, a reader node in the read-write pool takes over. | Up to 15 |
| Read-write pool | Contains the writer node and, optionally, reader nodes. | One |
| Read pool | Contains only reader nodes. | Up to 15 |
| Read-write endpoint | Connects to the writer node, including after a failover. | One |
| Read-only endpoint | Load balances connections across the reader nodes in its pool. | One for each pool |
| Storage | Holds the single copy of your data that all nodes share. | One |
Compute pools
A compute pool, or pool, is a group of nodes that share the same configuration. You configure compute at the pool level, and every node in the pool gets the same settings:
- Compute size - The processor type (AMD or Intel), compute generation, and number of vCores for each node.
- Node count - The number of nodes in the pool. To scale out reads, add reader nodes.
- High availability - How the pool protects against failures. High availability requires at least two nodes. With zone-redundant high availability, the pool's nodes are placed in at least two availability zones, which protects against an availability zone outage. For more information, see High availability in Azure HorizonDB.
- Firewall rules - The IP address ranges that can connect to the pool through public network access. By default, no IP addresses are allowed.
- Parameter group - The PostgreSQL server parameters that apply to every node in the pool.
Each pool also has its own read-only endpoint. For more information, see Endpoints.
A cluster has two kinds of pools:
- Read-write pool - Each cluster has exactly one read-write pool. It contains the writer node and, optionally, reader nodes. The reader nodes in this pool process reads, and they also provide high availability for the writer node. When you create a cluster in the Azure portal, Azure HorizonDB creates the read-write pool for you and names it
defaultpool. If you create a cluster another way, such as by using the REST API, the first pool that you create becomes the read-write pool. - Read pool - A read pool is an optional pool that contains only reader nodes. A cluster can have more than one read pool. Use read pools to run read workloads, such as reporting or analytics, on their own nodes that are sized for those workloads. Each read pool has its own compute size, node count, and read-only endpoint. Read pools aren't available yet, so each cluster currently has only its read-write pool. For more information, see Limitations.
Nodes
A node is a server that runs the PostgreSQL database engine and processes your queries and transactions. Each node has one of two roles:
- Writer node (read-write role) - The writer node is the only node in the cluster that can change data. It processes writes, such as
INSERT,UPDATE,DELETE, and data definition language (DDL) statements, and it can also process reads. Each cluster has exactly one writer node. - Reader node (read-only role) - A reader node processes reads, such as
SELECTqueries. Add reader nodes to horizontally scale reads across nodes. Reader nodes in the read-write pool also act as failover target. If the writer node becomes unavailable, Azure HorizonDB promotes one of them to be the new writer node. This process is called failover.
A cluster can have one writer node and up to 15 reader nodes in total, across all its pools.
Your data lives durably in shared storage. Every node reads from the same storage, so you can add a reader node quickly, without copying any data. To speed up access to frequently used data, each node keeps that data in its memory and in a local NVMe solid-state drive (SSD) cache. Each node gets 8 GB of memory and 32 GB of SSD cache for each vCore.
Nodes also hand off durability work to the storage layer, such as saving changed data, checkpointing, archiving WAL, sending WAL to reader nodes, and taking backups. This approach leaves more of each node's CPU, disk, and network capacity for your workload. For the full list of offloaded tasks, see Compute nodes in Azure HorizonDB.
You don't create, resize, or delete nodes one at a time. Instead, you configure the compute pool, and Azure HorizonDB creates and manages its nodes for you. Each node runs in a single availability zone, which is a physically separate group of datacenters within an Azure region.
Endpoints
An endpoint is a fully qualified domain name (FQDN) that your application uses as the host in its connection string. Endpoints route each connection to the right node, so your application doesn't need to know which node is the writer node or how many reader nodes exist. A cluster has two kinds of endpoints:
- Read-write endpoint - Each cluster has exactly one read-write endpoint. It always connects to the writer node in the read-write pool. After a failover, it automatically connects to the new writer node, so your application can reconnect without changing its connection string. Use this endpoint for writes and for reads that must return the most recently committed data.
- Read-only endpoint - Each pool has its own read-only endpoint, which load balances connections across the reader nodes in that pool. Use a read-only endpoint to scale out read workloads, such as reports and dashboards, without adding routing logic to your application.
Because reader nodes apply changes shortly after the writer node commits them, a query through a read-only endpoint might not include the most recent changes.
If the read-write pool has no reader nodes, its read-only endpoint connects to the writer node. In this case, connections through the read-only endpoint can also write data.
To find the FQDN of each endpoint, see Connection endpoints.
What you manage at each level
| Level | What you configure | What you can do |
|---|---|---|
| Cluster | PostgreSQL major version, PostgreSQL and Microsoft Entra authentication, public network access, private endpoints, data encryption, backup retention (1 to 35 days), geo-redundant backup, Microsoft Fabric mirroring, server log capture, and AI model management | Create, update, and delete the cluster. Restore a backup to a new cluster. Start a failover. |
| Compute pool | Compute size, node count, high availability, firewall rules, and parameter group | Scale the compute size or node count. |
| Node | None. Azure HorizonDB manages nodes for you. | View each node's role and availability zone. Azure HorizonDB handles node placement, maintenance, and failover. |
You choose the PostgreSQL major version, data encryption type, and geo-redundant backup when you create the cluster. You can't change them later.
Storage
All nodes in a cluster share a single copy of your data. Because storage is separate from compute, you don't attach disks to nodes or choose a storage size or input/output operations per second (IOPS). Storage grows automatically as your data grows, and you pay only for the storage that you use.
Azure HorizonDB storage has three layers. WAL storage and shared data storage are purpose-built services that record changes and serve data to the nodes. Azure Blob storage sits underneath them and provides durability. All three layers are zone-resilient: they keep copies of your data in multiple availability zones, so your data is protected if a zone fails.
WAL storage
The write-ahead log (WAL) is PostgreSQL's ordered record of every change to your data. WAL storage is a purpose-built, low-latency service that receives WAL from the writer node. Azure HorizonDB acknowledges a transaction to your application only after WAL storage durably stores the transaction's WAL.
WAL storage then delivers the WAL to the rest of the system in the background:
- It sends the WAL to shared data storage, which applies the changes to your data.
- It sends the WAL to every reader node, which applies the changes to the affected data in its memory.
- It archives the WAL to Azure Blob storage and keeps it for your backup retention period to support point-in-time restore.
Shared data storage
Shared data storage is a fleet of storage servers that holds your data and serves it to every node in the cluster. PostgreSQL stores tables and indexes in fixed-size blocks called data pages. When a node needs a data page that isn't in its memory or local SSD cache, it reads the page from shared data storage.
Shared data storage splits your data into shards, spreads the shards across many storage servers, and keeps multiple copies of each shard in different availability zones. It keeps your data current by applying WAL from WAL storage, and it writes updated data pages to Azure Blob storage.
Azure Blob storage
Azure Blob storage is the durable foundation of the storage layer. It stores your data pages and archived WAL in zone-redundant storage accounts, which keep copies in multiple availability zones within the region. Backups are snapshots of these blobs, so backups complete quickly regardless of database size and don't use your nodes' resources.
How a write flows through Azure HorizonDB
The following steps show what happens when your application changes data:
- Your application sends a change, such as an
INSERTstatement, through the read-write endpoint to the writer node. - The writer node sends the WAL for the change to WAL storage. After WAL storage durably stores the WAL, Azure HorizonDB acknowledges the transaction to your application.
- WAL storage sends the WAL to shared data storage and to every reader node, and each of them applies the change. Reader nodes typically reflect the change within milliseconds.
- WAL storage archives the WAL to Azure Blob storage, and shared data storage writes the updated data pages to Azure Blob storage.
- When any node needs the updated data page and the page isn't in its memory or local SSD cache, the node reads the page from shared data storage.
Price
Azure HorizonDB currently charges for:
- Provisioned Compute in core hours,
- Used database storage (GB/month), and
- Used backup storage for the short term retention period.
For more pricing details, view the pricing page.
Limitations
The following features aren't available yet.
| Feature | Status | Notes |
|---|---|---|
| Cross-region reader nodes | Not currently available | Reader nodes in another region aren't supported. For disaster recovery, use geo-redundant backup and restore to the paired region. |
| Read pools | Not currently available | Only one compute pool per cluster is supported. |
| Customer-managed keys (CMK) with geo-redundant backup | Not available | A cluster can use CMK or geo-redundant backup, but not both. |
| Custom maintenance windows and deferral | Not available | Maintenance uses a system-managed window. You can't select a custom window, reschedule an event, or defer maintenance. Maintenance notifications aren't available. See Scheduled maintenance. |
| In-place major version upgrade | Not currently available | You select the PostgreSQL major version when you create the cluster. In-place upgrades to a later major version aren't supported yet. |
| Connection Pooling (PgBouncer) | Not currently available | You can use an external connection pooler. |
| Long-term retention (LTR) | Not available | Backup retention is up to 35 days. |
| Index Tuning | Not currently available | Index tuning isn't currently available. |
| Virtual network injection | Not available | Azure Private Link is supported. Virtual network integration isn't supported yet. |
Note
This list reflects the current state of the service and is subject to change as new capabilities are released. Check the release notes for the latest updates.
Azure regions
Azure HorizonDB is currently available in the following Azure regions:
| Geography | Regions |
|---|---|
| Americas | Canada Central, Central US, East US, South Central US, West US 2, West US 3 |
| Europe | Germany West Central, Sweden Central |
| Asia Pacific | Australia East, India South Central, Indonesia Central, Japan East, Korea Central |
Note
Region availability is subject to change and we'll be adding more regions soon. Some regions might have restrictions on new deployments. For the latest region availability, see the Azure portal or contact Azure support.
Feedback and support
If you have questions or suggestions about Azure HorizonDB, you can get help and support through the following channels:
- To contact Azure Support, file a ticket from the Azure portal.
- To fix an issue with your account, file a support request in the Azure portal.