When building the sql-on-k8s-operator, I wanted to make sure it could handle both planned and unplanned failovers. The easy case is a planned failover, where you deliberately move the primary role to another replica. The harder case is an unplanned failover, where the primary pod just disappears. The operator needs to handle both.

I recently ran a full planned failover rotation on a three-replica SQL Server Availability Group managed by sql-on-k8s-operator, and I want to show you exactly what happens inside SQL Server and the operator during each hop. If you’ve been following my Introducing the SQL Server on Kubernetes Operator post, this is the logical next step: what does the error log actually look like during a planned failover, what does the operator do in response, and how long does the whole thing take?

I’ve been doing a deep dive into SQL Server on-disk structures lately, and one of my favorite rabbit holes is revisiting Paul Randal’s series on file header pages. If you haven’t read it, go do that now. It covers what file header pages are, what they contain, and what happens when they corrupt. This post takes that concept and runs with it. I’ll use DBCC FILEHEADER to read the file header of every user database file on a server and answer a question that comes up more than you’d think: can you determine which files belong together as a database purely from the file header, without querying sys.databases?

Are you considering replatforming your SQL Server workload due to recent vendor changes, but still need high availability and disaster recovery? You’re not alone. One of the challenges with running SQL Server on Kubernetes is that there’s no Kubernetes operator available. That means no automated lifecycle management, no automatic failover, and no standard way to bootstrap an Always On Availability Group on Kubernetes.

I’m excited to share it today as an open-source project: sql-on-k8s-operator. Let’s go.

Good news for anyone who’s been working around the AVX issue I wrote about in my previous post. Microsoft has fixed it in Cumulative Update 1 (CU1) for SQL Server 2025.

What Changed

Back in November when SQL Server 2025 RTM was released and I upgraded to macOS 26, I ran into an AVX instruction issue that prevented the container from starting on Docker Desktop using Rosetta on Apple Silicon. The container would crash with this error:

If you’re like me, you’ve probably been following Microsoft’s announcement about native NVMe support in Windows Server 2025 with great interest. While it’s limited to local drives, how about we break that rule and leverage our virtualization layer extend NVMe benefits throughout the entire storage stack, even to remote storage like a FlashArray? I decided to test that scenario, and the results are awesome. In this post, you will learn how to make your SQL Server workload about 25% faster without changing any code in your application. Let’s go.

Update (February 2, 2026): Microsoft has fixed this issue in SQL Server 2025 CU1. The container now runs successfully on Docker Desktop for macOS without needing OrbStack. See my follow-up post for details.

SQL Server 2025 RTM is here, and if you’re running Docker on macOS Tahoe 26, you might have hit a wall trying to get it running. Here’s what happened when I tried spinning up the latest container image and how I worked around it.

Introduction

When you’re running MongoDB at scale with data distributed across multiple Pure Storage FlashArrays, achieving truly consistent backups becomes a critical and interesting technical challenge. In this post, I’m walking through an automated snapshot and recovery solution for a sharded MongoDB cluster running across two separate FlashArrays. While this demonstration uses two nodes for clarity, the same approach scales to N nodes across N arrays. The coordination mechanism remains identical regardless of cluster size.

In my previous post, I showed you how to build a snapshot backup catalog using SQL Server 2025’s new native REST API integration. But what if you’re still running SQL Server 2022? Should you miss out on this powerful capability that SQL Server and Pure Storage provide? Absolutely not.

In this post, I’m going to show you how to build the same snapshot backup catalog functionality using PowerShell with SQL Server 2022’s T-SQL Snapshot Backup feature. While we don’t have the native REST integration yet, we can still leverage the power of FlashArray’s Protection Group Tags to build a queryable snapshot catalog that bridges the gap between database administration and storage management.

Update for SQL Server 2025:
This post and the GitHub repo have been updated for SQL Server 2025 RC1 and Ubuntu 24.04.
New in SQL Server 2025: You no longer need to install the PolyBase service to interact with Parquet files in S3. Previously, with SQL Server 2022, you had to build a custom container or manually install PolyBase. Now, S3 object integration and Parquet support work out-of-the-box!

---

In this blog post, I’ve implemented two example environments for using SQL Server’s S3 object integration. One for backup and restore to S3-compatible object storage and the other for data virtualization using PolyBase connectivity to S3-compatible object storage. This work aims to get you up and running as quickly as possible to work with these new features. I implemented this in Docker Compose since that handles all the implementation and configuration steps for you. The complete code for this is available on my GitHub repo. I’m walking you through the implementation here in this post.

SQL Server 2025 introduces native support for vector data types and external AI models. This opens up new scenarios for semantic search and AI-driven experiences directly in the database. But as with any external service integration, performance and scalability are immediate concerns, especially when generating embeddings at scale.

https://github.com/nocentino/ollama-lb-sql

Problem: Bottlenecks in Embedding Generation

When you call out to an external embedding service from T-SQL via REST over HTTPS, you’re limited by the throughput of that backend. If you’re running a single Ollama instance, you’ll quickly hit a ceiling on how fast you can generate embeddings, especially for large datasets. I recently attended an event and discussed this topic. My first attempt at generating embeddings was for a three-million-row table. I had access to some world-class hardware to generate the embeddings. When I arrived at the lab and initiated the embedding generation process for this dataset, I quickly realized it would take approximately 9 days to complete. Upon closer examination, I found that I was not utilizing the GPUs to their full potential; in fact, I was only using about 15% of one GPU’s capacity. So I started to cook up this concept in my head, and here we are, load balancing embedding generation across multiple instances of ollama to more fully utilize the resources.