Under the Hood of the Azure SQL Database Container: Native ARM64

Page content

Today at Ignite, Microsoft announced the public preview of the Azure SQL Database container. The line in the announcement that jumped out at me was this one: the container runs natively on x64 and ARM64, including Apple Silicon. If you’ve been following along with my posts on running SQL Server on Apple Silicon and the AVX issue under Rosetta, you know I’ve been waiting a long time to type that sentence.

So I did what any reasonable person would do on announcement day. I pulled the image, started it up next to a SQL Server 2025 CU11 container on my M4 Pro, and started taking both of them apart. I wanted to know two things. First, how did Microsoft get a SQL engine running natively on ARM64? Is it emulation? A brand new engine? Second, how does a container on my laptop pretend to be a managed cloud service?

In this post, I’m going to show you what’s inside the image, how Microsoft built it for ARM64, and how a control plane running inside the container makes it behave like Azure SQL Database. Then we’ll compare it to SQL Server 2025 on database defaults and performance. Let’s go.

The Problem We’re Solving

If you develop against Azure SQL Database on a Mac, your local options have been pretty rough. Here’s what’s been hurting:

  • Everything runs through Rosetta: The SQL Server container images are amd64 only, so on Apple Silicon every instruction goes through Rosetta translation. As we saw with the AVX issue in SQL Server 2025 RTM, that translation layer can break in ways that are hard to work around.
  • No native ARM64 option: Azure SQL Edge was the ARM64 answer for local development, and it’s been retired.
  • Box defaults aren’t cloud defaults: Most of us test Azure SQL Database applications against a SQL Server container. A new database in SQL Server has RCSI off, no accelerated database recovery, and MAXDOP 0, and it lets you do things Azure SQL Database won’t, like USE and cross-database queries. That means some bugs don’t show up until you deploy.

The Azure SQL Database container goes after all three of these at once.

My Lab Setup

Here’s what I tested today on my Mac:

Component Details
Host MacBook Pro, Apple M4 Pro, 12 cores
Container runtime Docker Desktop 4.96.3 (Engine 29.9.2), linux/arm64 VM
Azure SQL Database container mcr.microsoft.com/mssql/azure-sql-db-server:latest
SQL Server 2025 mcr.microsoft.com/mssql/server:2025-CU11-ubuntu-24.04

Step 1: Start Both Containers

The Azure SQL Database container starts just like the SQL Server container you already know. Same environment variables, same data path:

docker run --name sqldb \
   -e "ACCEPT_EULA=Y" 
   -e "MSSQL_SA_PASSWORD=<password>" \
   -p 127.0.0.1:1433:1433 
   -v sqldb-data:/var/opt/mssql \
   -d mcr.microsoft.com/mssql/azure-sql-db-server:latest

docker run --name sql2025 --platform linux/amd64 \
   -e "ACCEPT_EULA=Y"
   -e "MSSQL_SA_PASSWORD=<password>" \
   -p 127.0.0.1:1434:1433 
   -v sql2025-data:/var/opt/mssql \
   -d mcr.microsoft.com/mssql/server:2025-CU11-ubuntu-24.04

Before we go any further, let’s look at the image manifests. This tells us which CPU architectures each image was built for:

docker manifest inspect -v mcr.microsoft.com/mssql/azure-sql-db-server:latest

azure-sql-db-server:latest
                        "platform": {
                                "architecture": "arm64",
                                "os": "linux"
                        }
                        ...output omitted
                        "platform": {
                                "architecture": "amd64",
                                "os": "linux"
                        }

docker manifest inspect -v mcr.microsoft.com/mssql/server:2025-CU11-ubuntu-24.04

server:2025-CU11-ubuntu-24.04
                        "platform": {
                                "architecture": "amd64",
                                "os": "linux"
                        }

Look at the architecture values. The sqldb manifest lists two platforms, arm64 and amd64, and the SQL Server 2025 manifest lists only amd64. The Azure SQL Database container is a multi-arch image with a real arm64 build, and SQL Server 2025 CU11 is still amd64 only. On Apple Silicon, Docker pulls the arm64 variant of the sqldb image automatically. The SQL Server 2025 image has nothing to offer an ARM64 host, so it runs under emulation. I pass --platform linux/amd64 to make that explicit.

Step 2: Confirm What’s Actually Running

Next, let’s look at the process list inside each container and see which binary is executing each process:


# sqldb
docker exec sqldb sh -c 'uname -a; ps -elf'

Linux 8485534e5329 7.0.14-linuxkit #1 SMP PREEMPT Fri Oct 16 11:55:50 UTC 2026 aarch64 aarch64 aarch64 GNU/Linux
F S UID          PID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 S mssql          1       0  0  80   0 -  1146 do_wai Nov17 ?        00:00:00 /bin/bash /opt/mssql/bin/launch_sqlservr.sh /opt/mssql/bin/sqlservr
4 S mssql         39       1  0  80   0 - 206114 -     Nov17 ?        00:00:01 /opt/sqldbdev-cp/minicp/MiniCP
4 S mssql         62       1  0  80   0 - 15652 -      Nov17 ?        00:00:00 /opt/mssql/bin/sqlservr -xdb -T6529
5 S mssql         64      62  1  80   0 - 3637229 -    Nov17 ?        00:02:47 /opt/mssql/bin/sqlservr -xdb -T6529
4 R mssql        247       0 99  80   0 -  1133 -      02:24 ?        00:00:00 ps -elf


# sql2025
docker exec sql2025 sh -c 'uname -a; ps -elf'

Linux sql1 7.0.14-linuxkit #1 SMP PREEMPT Fri Oct 16 11:55:50 UTC 2026 x86_64 x86_64 x86_64 GNU/Linux
F S UID          PID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 S mssql          1       0  0  80   0 - 125018 do_wai Nov17 ?       00:00:00 /bin/bash /opt/mssql/bin/launch_sqlservr.sh /opt/mssql/bin/sqlservr
4 S mssql         10       1  0  80   0 - 141303 -     Nov17 ?        00:00:00 /run/rosetta/rosetta /opt/mssql/bin/sqlservr /opt/mssql/bin/sqlservr
5 S mssql         12      10  5  80   0 - 3566319 -    Nov17 ?        00:08:14 /run/rosetta/rosetta /opt/mssql/bin/sqlservr /opt/mssql/bin/sqlservr
4 S mssql      10447       0 20  80   0 - 124569 do_wai 02:25 ?       00:00:00 sh -c uname -a; ps -elf
4 R mssql      10454   10447 60  80   0 - 125893 -     02:25 ?        00:00:00 ps -elf

Look at the SQL Server 2025 output first. Every single process, even the bash launch script, is being executed by /run/rosetta/rosetta. That’s Apple’s x86_64 translation layer doing all the work. On the sqldb side, the kernel reports aarch64 and there’s no Rosetta anywhere. There are two more interesting things in the sqldb output, though. A second process called MiniCP is running alongside the engine, and sqlservr is started with two arguments you won’t see on the box product: -xdb and -T6529. We’ll get to both of those.

Now let’s ask each engine what it thinks it is:

SELECT @@VERSION;
SELECT SERVERPROPERTY('EngineEdition') AS EngineEdition, SERVERPROPERTY('Edition') AS Edition;

-- sqldb
Microsoft SQL Azure (RTM) - 12.0.2000.8
	Nov 16 2026 07:53:58
	Copyright (C) 2026 Microsoft Corporation

EngineEdition Edition
------------- ---------
5             SQL Azure

-- sql2025
Microsoft SQL Server 2025 (RTM-CU11) (KB5129223) - 17.0.5065.9 (X64)
	Nov  4 2026 14:59:40
	Copyright (C) 2025 Microsoft Corporation
	Enterprise Developer Edition (64-bit) on Linux (Ubuntu 24.04.5 LTS) <X64>

EngineEdition Edition
------------- -------------------------------------
3             Enterprise Developer Edition (64-bit)

The sqldb container reports itself exactly like Azure SQL Database does, 12.0.2000.8 and EngineEdition 5, so your application’s version checks behave the same way they would in the cloud. The image label says something else, though. The engine build is 18.0.256.6210, and SQL Server 2025 is version 17. So this is a newer engine branch than anything shipping on-premises today, wearing an Azure SQL Database name badge. @@VERSION doesn’t mention the CPU at all, but the errorlog banner does:

docker exec sqldb head -4 /var/opt/mssql/log/errorlog

2026-11-17 23:56:03.29 Server      Microsoft SQL Azure (RTM) - 12.0.2000.8 (ARM64)
	Nov 16 2026 07:53:58
	Copyright (C) 2026 Microsoft Corporation
	SQL DB Developer Edition (64-bit) on Linux (Microsoft Azure Linux 3.0 aarch64) <ARM64>

There it is: (ARM64), a SQL DB Developer Edition, running on Azure Linux 3.0 aarch64.

How Microsoft Got SQL Server Running on ARM64

First, a quick refresher. SQL Server on Linux runs on the SQL Platform Abstraction Layer, SQLPAL. The sqlservr binary in the process list is a small Linux program, about 7 MB, whose job is to host a Windows user-mode environment and load the real SQL Server engine DLLs into it. Those Windows binaries, hundreds of megabytes of them, ship inside .sfp package files in /opt/mssql/lib. So making sqlservr run on ARM64 is the easy part. The interesting work is inside those packages.

Step 3: Look Inside the SFP Packages

I wrote a small Python script, sfpscan.py, that walks the file table inside an .sfp package and reads the header of every Windows binary to find out which CPU it was compiled for. You can grab the script here.

Let’s copy the four main packages out of each container and run the script against them:

mkdir -p sqldb sql2025
for f in sqlservr.sfp system.common.sfp system.netfx.sfp system.sfp; do
  docker cp sqldb:/opt/mssql/lib/$f sqldb/
  docker cp sql2025:/opt/mssql/lib/$f sql2025/
done
python3 sfpscan.py sqldb/*.sfp sql2025/*.sfp

sqldb/sqlservr.sfp: sfp v2 {'ARM64': 114, 'AMD64': 7, 'I386': 10}
sqldb/system.common.sfp: sfp v2 {'ARM64': 215, 'I386': 54}
sqldb/system.netfx.sfp: sfp v2 {'AMD64': 34, 'ARM64': 45, 'I386': 61}
sqldb/system.sfp: sfp v2 {'ARM64': 36, 'AMD64': 1}
sql2025/sqlservr.sfp: sfp v1 {'AMD64': 211, 'I386': 21, 'ARM64': 1}
sql2025/system.common.sfp: sfp v1 {'AMD64': 267, 'I386': 52}
sql2025/system.netfx.sfp: sfp v1 {'AMD64': 139, 'I386': 765}
sql2025/system.sfp: sfp v1 {'AMD64': 48}

This is a full native ARM64 recompile. Look at sqlservr.sfp, the engine package: 114 ARM64 binaries in sqldb against 211 AMD64 binaries in SQL Server 2025. The other packages follow the same pattern, apart from a few AMD64 leftovers I’ll come back to. (You can ignore the I386 entries. Those are .NET assemblies, which carry that tag no matter where they run.) Here’s what that covers, layer by layer:

Layer Example files sqldb SQL 2025
Windows user mode ntdll.dll, KernelBase.dll ARM64 AMD64
SQLPAL sqlpal.dll ARM64 AMD64
SQL Server engine sqlservr.exe, sqlmin.dll, sqllang.dll ARM64 AMD64
.NET Framework for SQLCLR clr.dll, clrjit.dll ARM64 AMD64

Microsoft rebuilt every layer, from the Windows user-mode environment up through the engine and the .NET Framework. A Windows user-mode environment, compiled for ARM64, running on Linux, inside a VM, on a Mac. No pressure.

Step 4: Create a Database and Compare the Defaults

I created one on each engine with the same statement:

CREATE DATABASE appdb;

Then I connected to appdb on each engine (remember, USE doesn’t work in Azure SQL Database, so connect with -d appdb) and compared the settings each one ended up with:

SELECT name, compatibility_level, is_read_committed_snapshot_on, snapshot_isolation_state, is_accelerated_database_recovery_on, is_optimized_locking_on, is_query_store_on, is_encrypted
FROM sys.databases WHERE name = 'appdb';

SELECT DATABASEPROPERTYEX('appdb','Edition') AS Edition,
       DATABASEPROPERTYEX('appdb','ServiceObjective') AS ServiceObjective;

SELECT name, actual_state_desc FROM sys.database_automatic_tuning_options WHERE name = 'FORCE_LAST_GOOD_PLAN';

SELECT value AS maxdop FROM sys.database_scoped_configurations WHERE name = 'MAXDOP';

Here are the results side by side:

Setting sqldb SQL 2025
Edition / Service Objective Hyperscale / HS_Gen5_8 NULL
Read Committed Snapshot ON OFF
Snapshot Isolation ON OFF
Accelerated Database Recovery ON OFF
Optimized Locking ON OFF
TDE ON OFF
Query Store ON ON
FORCE_LAST_GOOD_PLAN ON OFF
Database scoped MAXDOP 8 0

Same CREATE DATABASE statement, two very different databases. The sqldb database looks like a new Azure SQL Database: RCSI on, ADR and optimized locking on, TDE on, automatic plan correction on, and MAXDOP set to 8. This is the whole point of the container. If your application has a concurrency bug that only shows up under RCSI, or a query that behaves differently at MAXDOP 8, you’ll find it on your laptop instead of in production.

Native ARM64 vs. Rosetta: Performance

Finally, I wanted numbers. I ran the same T-SQL script on both engines: a tight WHILE loop, a 2 million row insert, hash aggregation at DOP 1 and DOP 8, a clustered columnstore build, and a batch mode scan. You can grab the script here.

Here are the times in milliseconds from the second run on each engine:

Test sqldb (ARM64 native) SQL 2025 (x64, Rosetta)
T-SQL loop, 3M iterations 2,909 4,347
INSERT 2M rows 6,680 7,619
Hash aggregate, DOP 1 413 336
Hash aggregate, DOP 8 56 42
Clustered columnstore build 13,465 16,152
Batch mode scan, DOP 1 26 49

Native ARM64 wins clearly on the CPU heavy work. The T-SQL loop is about 1.5x faster, the columnstore build about 1.2x faster, and the batch mode scan almost 2x faster. The hash aggregation went the other way. Your mileage will certainly vary.

A Few Things to Know About the Preview

This is a preview, and I ran into a couple of rough edges you should know about before you build on it.

  • No backup or restore: I wanted to seed a database from a .bak I already had. The launch script has a “relax” mode, MSSQL_SQLDBDEV_RELAX=1, that turns on a feature switch called AllowBackupRestoreInSds. The switch gets written, but RESTORE DATABASE, RESTORE HEADERONLY, and BACKUP DATABASE all still fail with Statement 'RESTORE DATABASE' is not supported in this version of SQL Server. For now, load your data with a BACPAC, SqlPackage, or scripts.
  • The health check isn’t wired up: The image ships a nice container-healthcheck.sh that reports healthy only when the engine is listening and MiniCP has finished configuring the databases. But the published image config has no health check, so docker inspect never shows a health status. In Docker Compose or CI, add one yourself pointing at /opt/mssql/bin/container-healthcheck.sh.

Why This Matters

  1. Native ARM64 SQL on your Mac: Azure SQL Edge is gone, and the SQL Server image is still amd64 only. This is now the native ARM64 option for SQL Server engine work on Apple Silicon, and it’s fast.
  2. Cloud behavior on your laptop: You get the same version string, the same per-database defaults, and the same tier feature switches as the service. Bugs tied to how Azure SQL Database behaves show up during development instead of after you deploy.
  3. No Azure subscription required: You can run it disconnected, tear it down, and start over in seconds, which makes it a great fit for CI pipelines and integration tests.

Wrapping Up

The key thing here is that Microsoft didn’t build a new database for this. They took the same SQL Server engine and the same SQLPAL architecture you already run on Linux, recompiled it for ARM64 from the Windows layer all the way up, started it in its Azure mode, and paired it with a small Rust control plane that stands in for the Azure management service. I really like that approach. Because it’s the real engine running the real feature switches, the container stays faithful to the cloud service without anyone having to maintain a separate emulator.

Two things to keep in your head when you try it. Plan on a BACPAC or scripts to load data, because backup and restore are blocked. And add your own container health check, because the one in the image isn’t registered.

Check out the announcement post for the getting started steps and the preview FAQ. Get out in your lab and try it. Let me know how it works in your environment.