Press "Enter" to skip to content

Category: Deployment

Creating an Azure DevOps Deployment

Reitse Eskens deploys some Microsoft Fabric assets:

Let me generalise first: you can essentially choose two options to promote your hand-crafted and superior code compared to anyone else from development to production. The first way is to use the Fabric deployment pipelines. These are essentially copy actions that move the development state to production. Option two is to use either GitHub Actions or Azure DevOps pipelines.

The main issue I’ve seen with the Fabric deployment pipelines is that the deployed code still references the development environment. This results in your notebook running in production and happily writing the results in the development lakehouse. To mitigate this, you can add actions to the Fabric pipeline, check out the newly announced Fabric deployment plans, or remember to update all references.

Click through for a high-level depiction of the process.

Leave a Comment

Skipping Incompatible Objects in Bacpac Restoration

Erik Ejlskov Jensen shares some good news:

If you have ever tried to export a SQL Server database to a .bacpac file with sqlpackage, you have most likely run into the dreaded SQL71627 error, complaining about a Windows user or login. I ran into it myself a few years ago, and the only workaround was to drop the offending users from the database (or a copy of it) before running the export.

With sqlpackage 170.6.28-preview, that workaround is no longer needed. The Export action has two new properties that let you remove objects that are not compatible with Azure SQL Database while exporting, and write a report of what was removed.

Click through for a demonstration.

Leave a Comment

Rebuilding pgbuild

Dave Page digs into a repo:

My job at pgEdge allows me a significant amount of time to work on pgAdmin, a project I started nearly 30 years ago. The previous blog and this followup is an update on some of the recent work I’ve been doing.

In my last post I wrote about moving pgAdmin’s build farm from Jenkins to GitHub Actions, and I promised a follow-up about pgbuild, which is the least famous repository in the pgAdmin organisation and quietly one of the most important. If you have installed pgAdmin on Windows in the last year or so, or on macOS since the move to GitHub Actions, you ran code that came from the buildfarm.

Click through to learn more about this base repository, as well as one significant problem they fixed.

Leave a Comment

CI/CD for Report Development

Eugene Meidinger checks in some reports:

Continuous Integration / Continuous Delivery (CI/CD) is the software development practice of constantly having new features and changes be saved and brought into a shared environment (integration) and then built into a state for testing and review (delivery). This is in contrast to doing all of your report development in a single PBIX file, making a large batch of changes, and then deploying them all to production.

It’s tempting to assume that these practices are only for large enterprises or professional software companies. In this article, we argue that many CI/CD and related practices form a maturity ladder you can climb, incrementally. Even basic steps can be useful. This is true even if you are the only developer in an organization. To use an analogy, you should still wear a seatbelt even if you aren’t a professional racecar driver.

Click through for Eugene’s advice. Granted, the amount of applicable advice when you’re working with Power BI Report Server is…less.

Leave a Comment

Choosing a Fabric Rollout Strategy

Paul Turley makes a recommendation:

Pilot versus enterprise-wide is the wrong debate. The real question is which one your organization is actually ready for.

Start narrow, then earn scale.

Microsoft’s capacity planning guidance recommends beginning with a proof-of-concept phase on a free 60-day trial capacity, a single use case, a small user group, and an isolated workspace so nothing touches production. You’re testing the concept, not committing the whole company. That isolation matters as much as the scope — keeping the proof-of-concept out of production workspaces means a bad assumption costs you a workspace, not a week of executive reporting.

Read on for a few more tips along these lines.

Comments closed

Working with Deployment Plans in Microsoft Fabric

Kevin Chant digs into a new announcement:

To clarify, deployment plans are a new type of Microsoft Fabric item that lets you control deployment order and automate actions as part of the deployment. For example, you can define a plan that first creates a Lakehouse and then runs a notebook afterwards to insert it with data.

Deployment plans are not another deployment option. Instead, they enrich the deployment options that are already available. At this moment in time they work with Git integration, Deployment Pipelines and supported REST APIs.

Read on to learn more about these.

Comments closed

Building an Azure DevOps Extension for Microsoft Fabric

Kevin Chant gives us the rundown:

When I first released the extension, I decided to keep the source code private. Having invested significant time developing and testing it, I wanted to first establish the extension.

Now that the source code is available in a GitHub repository I decided to share my experiences to help others create their own Azure DevOps extensions. Because there is more to creating an extension then just modifying the source code.

Click through for Kevin’s lessons learned.

Comments closed

The Pain of Microsoft Fabric Deployment Pipelines

Meagan Longoria has a list:

Fabric deployment pipelines look like they solve CI/CD for Fabric content, especially for people who prefer a GUI over writing code to handle deployments, but the implementation has enough structural gaps that they fall apart for several real deployment workflows. Even when they do work, the UI isn’t always intuitive.

Every piece of active software carries a backlog of feature requests and known limitations, and deployment pipelines get new capabilities on a regular basis. Everything below reflects how deployment pipelines behave as of August 2026. Some of it may have changed by the time you’re reading this, so check Microsoft’s docs for the current state before you plan around any of these.

Click through for the list, as well as a few alternatives that come with their own trade-offs.

Comments closed

Validating Selective Deployments in Microsoft Fabric

Matt Collins shares some advice:

Selective deployments with the fabric-cicd python library are highly useful for shipping just the items that actually changed in your CI/CD process. Unfortunately, by default, it also tells you that a deployment succeeded when nothing was deployed at all.

This blog showcases an example where we selectively deployed Fabric items to upper environments, not realising that the dev ops pipeline reported as “successful” but did not contain our intended changes. We will then dig into some quality checks that highlighted a bigger error in the way Microsoft Fabric handles item naming in a repository.

You’ll learn how to help safeguard from human error in selective Fabric deployments, as well as create useful build validations in Azure DevOps that help to keep your repository resource names clean and fit-for-purpose. All this is achieved through two simple CI/CD pipelines.

Read on to learn more.

Comments closed

Blocking Database Project Deployment on Data Loss

Jerry Nixon flips a switch:

This important feature shows up in a few places. This article discusses its role in Database Projects and in SQL Server Management Studio (SSMS); it defaults to true in both. This simple setting evaluates the delta between your desired schema and your actual schema and calculates if applying your desired schema would result in data loss. If the answer is “yes,” it stops.

An easy example is dropping a table or column. Doing so would clearly lose data. Another, perhaps less obvious, is reducing the range of a column’s data type, like from INT to TINYINT, where any existing value under zero or over 255 could be lost. These evaluations are done by the engine when BlockOnPossibleDataLoss is set to True and, as a result, you can trust that data in your database is not accidentally destroyed by publishing a schema.

The tricky part becomes dealing with database changes when there will be data loss. For that scenario, I’m not sure the database project approach offers anything significant over writing your own database change scripts.

Comments closed