Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
W tym samouczku utworzysz kompletny, powtarzalny proces wydawania dla platformy Microsoft Fabric przy użyciu infrastruktury jako kodu. Konfigurujesz dwa obszary robocze (dev i test) za pomocą Terraform, łączysz obszar roboczy dev z usługą Git, tworzysz element w obszarze dev, a następnie promujesz go do obszaru test przy użyciu biblioteki Python fabric-cicd. Wszystko działa pod jednym principem usługi, więc ten sam przepływ działa dziś na laptopie, a jutro w pipeline CI/CD.
W tym samouczku nauczysz się następujących rzeczy:
- Udostępnianie przestrzeni roboczych dla deweloperów i testów, połączenia z Gitem oraz przypisania ról w Terraform.
- Połącz obszar roboczy dewelopera z repozytorium Git usługi Azure DevOps.
- Napisz notatnik i domek nad jeziorem w programowaniu deweloperskim i wprowadź je do Gita.
- Promuj zawartość ze środowiska deweloperskiego do środowiska testowego za pomocą fabric-cicd.
- Sprawdź, czy wdrożony notes jest ponownie powiązany z testowym lakehouse’em.
Dwa samoloty, dwa narzędzia
Automatyzacja procesu wydawania w Fabric obejmuje dwa odrębne aspekty i warto je rozdzielić: stabilną płaszczyznę sterowania (infrastrukturę, w której znajdują się Twoje treści) oraz zmienną płaszczyznę danych (treści, które codziennie edytujesz). Dopasuj narzędzie do wdrażania do tego, jak często każda rzecz się zmienia.
- Płaszczyzna sterowania mieści infrastrukturę nieulotną, którą konfigurujesz raz i rzadko zmieniasz: pojemności, przestrzenie robocze i ich ustawienia, domeny, połączenia, ustawienia tenantów oraz okablowanie RBAC i Git. Ten samouczek tworzy go za pomocą Terraform.
- Warstwa danych zawiera nietrwałą zawartość, która zmienia się w każdym sprincie i przepływa przez Git: notesy, lakehouse’y i magazyny danych, modele semantyczne i raporty, potoki i przepływy danych oraz wartości biblioteki Variable Library. Ten samouczek przenosi go za pomocą fabric-cicd.
Idea przewodnia: stabilną platformę należy przygotować raz za pomocą Terraform, a następnie pozwolić zmiennym elementom nieprzerwanie przepływać przez Git i fabric-cicd.
To jedno z podejść do automatyzacji Fabric, faworyzujące zespoły, które już traktują infrastrukturę jak kod i chcą mieć skryptowalną, sterowaną przez źródła konfigurację. Fabric oferuje także pipeline'y wdrożeniowe oparte na portalach oraz integrację z Gitem, które można sterować z interfejsu bez pisania w Terraform czy Python. Porównanie opcji można znaleźć w artykule o opcjach przepływu CI/CD w Fabric.
Jeśli chodzi konkretnie o wdrażanie na płaszczyźnie danych, jedną z opcji jest fabric-cicd. Możesz także bezpośrednio wywołać REST API Fabric bulk (CRUD), jeśli chcesz mieć pełną kontrolę nad tworzeniem, aktualizacją i usuwaniem wywołań bez konieczności uzależniania od biblioteki. Ten samouczek używa fabric-cicd, ponieważ obsługuje za Ciebie ponowne powiązanie specyficzne dla środowiska.
Dlaczego Terraform do płaszczyzny sterowania
- Deklaratywna i idempotentna. Opisujesz pożądany stan swoich miejsc pracy raz; Terraform tworzy to, czego brakuje, a resztę zostawia w spokoju.
- Wykrywanie dryfu.
terraform planpokazuje dokładnie, czym aktywny tenant różni się od źródła referencyjnego, dzięki czemu zmiana wprowadzona poza portalem staje się widoczna i możliwa do cofnięcia. - Jeden dostawca dla wielu zasobów. Dostawca Microsoft Fabric zarządza przestrzeniami roboczymi, pojemnościami, połączeniami, łączami Git oraz RBAC za pomocą API Fabric REST.
Dlaczego Fabric-CICD w płaszczyźnie danych
- Wdraża się tak, jak oczekuje Fabric. Fabric-CICD odczytuje reprezentację Twoich elementów w Gicie i publikuje je z poprawną semantyką tworzenia lub aktualizacji, więc nie musisz ręcznie generować wywołań REST.
- Parametryzacja. Plik
parameter.ymlponownie wiąże wartości specyficzne dla środowiska, na przykład ustawiając domyślny lakehouse notesu lub połączenie modelu semantycznego tak, aby wskazywały właściwy element docelowy w danym środowisku. - Oczyszczanie. Może wycofać z publikacji elementy usunięte z repozytorium Git, dzięki czemu każde środowisko pozostaje wiernym odzwierciedleniem gałęzi, którą śledzi.
Przepływ od końca do końca
Oba samoloty łączą się w jedną, ciągłą automatyzację. Platformę konfigurujesz raz, a od tego momentu każda zmiana treści powtarza się w tej samej powtarzalnej pętli — od edytora, przez Git, aż po środowisko testowe — bez ręcznych kroków portalu pomiędzy.
Ten sam princip usługi uwierzytelnia każdy etap, więc przepływ, który uruchamiasz ręcznie w tym samouczku, jest dokładnie tym, co uruchamia CI/CD pipeline w Twoim imieniu: etap provisionowania (Terraform), potem etap wdrażania (fabric-cicd), który uruchamia się za każdym razem, gdy zmienia się śledzona gałąź. Każdy etap odpowiada poniższemu krokowi:
| Etapie | Narzędzie | Krok samouczka |
|---|---|---|
| Skonfiguruj platformę (jednorazowo) | Terraform | Krok 1 |
| Napisz zmianę i zatwierdz ją (CI) | Fabric + Git | Krok 2–Krok 3 |
| Wdrożenie dewelopera do testu (CD) | Fabric-CICD | Krok 4 |
| Weryfikowanie wyniku | — | Krok 5. |
Ważne
Ta automatyzacja od początku do końca łączy obszar roboczy dewelopera z Git w trybie nieinteraktywnym przy użyciu jednostki usługi. Ten sam podmiot usługowy musi mieć również dostęp do powiązanej organizacji, projektu i repozytorium Azure DevOps, aby móc nawiązać połączenie i synchronizować w Twoim imieniu. Użycie jednostki usługi do połączenia obszaru roboczego z GitHub nie jest obecnie obsługiwane, więc w tym przepływie użyj usługi Azure DevOps. Nadal możesz korzystać z GitHub za pośrednictwem integracji Git za pośrednictwem portalu, ale automatyczny krok łączenia opisany w tym samouczku nie będzie mieć zastosowania.
Wymagania wstępne
- Fabric pojemność. Oba obszary robocze w tym samouczku są przypisane do tej samej funkcji. Pojemność testowa działa.
- Zasada usługi (rejestracja aplikacji Microsoft Entra) z tajemnicą klienta. Ta pojedyncza tożsamość zapewnia przestrzenie robocze i uruchamia wdrożenie.
- Ustawienie dzierżawy Jednostki usługi mogą używać interfejsów API usługi Fabric jest włączone dla grupy zabezpieczeń zawierającej jednostkę usługi. Więcej informacji można znaleźć w artykule Włącz uwierzytelnianie zasady usługi dla Fabric API.
- Organizacja, projekt i repozytorium Git Azure DevOps, do którego może korzystać operator usługi. Repozytorium musi już zawierać gałąź (na przykład
main) oraz folder, który ustawiłeś (ado_directory_namena przykład/workspace). Połączenie z repozytorium Git używaPreferRemote, które odczytuje ten folder w tej gałęzi podczas nawiązywania połączenia, więc oba elementy muszą istnieć wcześniej. Jeśli folder nie istnieje,terraform applykończy się błędemGitProviderResourceNotFound. Aby go utworzyć, zatwierdz pusty plik zastępczy (np..gitkeep) na tej ścieżce na gałęzi przed uruchomieniem Terraform. - Następujące narzędzia zainstalowane lokalnie:
Ważne
Jednostka usługi potrzebuje wystarczających uprawnień, aby tworzyć obszary robocze w tej pojemności i aby można było dodać ją jako administratora obszaru roboczego. Przyznaj jej uprawnienia współtwórcy pojemności (lub administratora) i upewnij się, że należy do grupy zabezpieczeń wskazanej w ustawieniu dzierżawy wymienionym powyżej.
Konfigurowanie uwierzytelniania
Zarówno Terraform, jak i fabric-cicd uwierzytelniają się jako główny operator usługi. Eksportuj jego dane uwierzytelniające jako zmienne środowiskowe, aby oba narzędzia mogły je przejąć:
export FABRIC_TENANT_ID="<tenant-id>"
export FABRIC_CLIENT_ID="<app-client-id>"
export FABRIC_CLIENT_SECRET="<client-secret>"
# fabric-cicd (via DefaultAzureCredential) reads the AZURE_* names:
export AZURE_TENANT_ID="$FABRIC_TENANT_ID"
export AZURE_CLIENT_ID="$FABRIC_CLIENT_ID"
export AZURE_CLIENT_SECRET="$FABRIC_CLIENT_SECRET"
Wskazówka
W potoku te wartości pozyskuj z połączenia usługowego lub tajnego magazynu, takiego jak Azure Key Vault, zamiast wpisywać je w shell. Nigdy nie zatwierdzaj poufnych danych do repozytorium Git.
Krok 1: Udostępnij przestrzenie robocze za pomocą Terraform
W tym etapie definiujesz płaszczyznę sterowania jako kod i stosujesz ją. Stwórz folder dla konfiguracji Terraform i dodaj następujące pliki.
Konfiguruj dostawcę
Stwórz provider.tf. Przypięcie wersji dostawcy zapewnia wszystkim inżynierom identyczne działanie.
# We strongly recommend using the required_providers block to set the Fabric Provider source and version being used
terraform {
required_version = ">= 1.8, < 2.0"
required_providers {
fabric = {
source = "microsoft/fabric"
version = "1.12.0"
}
}
}
# Configure the Microsoft Fabric Terraform Provider.
# Auth is via the service principal exported as FABRIC_TENANT_ID /
# FABRIC_CLIENT_ID / FABRIC_CLIENT_SECRET. Never hard-code secrets here.
provider "fabric" {
# Configuration options
}
Deklaruj wejścia
Stwórz variables.tf:
variable "capacity_name" {
description = "Name of an existing Fabric capacity that backs both workspaces."
type = string
}
variable "workspace_prefix" {
description = "Prefix for the workspace display names."
type = string
default = "releaseflow"
}
# Azure DevOps Git settings for the DEV workspace.
variable "ado_organization_name" {
type = string
}
variable "ado_project_name" {
type = string
}
variable "ado_repository_name" {
type = string
}
variable "ado_branch_name" {
type = string
default = "main"
}
variable "ado_repo_url" {
type = string
}
variable "ado_directory_name" {
type = string
default = "/workspace"
}
# Service principal used by the source-control connection.
variable "tenant_id" {
type = string
}
variable "client_id" {
type = string
}
variable "client_secret" {
type = string
sensitive = true
}
# Object id of the developer or group to grant Contributor on DEV.
variable "contributor_principal_id" {
type = string
}
Zdefiniuj zasoby
Stwórz main.tf. Ta konfiguracja tworzy dwa obszary robocze, połączenie z systemem kontroli źródła, połączenie Git w środowisku dev oraz przypisania ról.
data "fabric_capacity" "capacity" {
display_name = var.capacity_name
}
# DEV workspace — authored here, committed to Git.
resource "fabric_workspace" "dev" {
display_name = "${var.workspace_prefix}-dev"
description = "Development workspace."
capacity_id = data.fabric_capacity.capacity.id
}
# TEST workspace — populated by fabric-cicd from the Git repo.
resource "fabric_workspace" "test" {
display_name = "${var.workspace_prefix}-test"
description = "Test workspace."
capacity_id = data.fabric_capacity.capacity.id
}
# Source-control connection (service principal).
resource "fabric_connection" "ado" {
display_name = "${var.workspace_prefix}-ado-conn"
connectivity_type = "ShareableCloud"
privacy_level = "Organizational"
connection_details = {
type = "AzureDevOpsSourceControl"
creation_method = "AzureDevOpsSourceControl.Contents"
parameters = [{ name = "url", value = var.ado_repo_url }]
}
credential_details = {
credential_type = "ServicePrincipal"
skip_test_connection = false
service_principal_credentials = {
client_id = var.client_id
client_secret_wo = var.client_secret
client_secret_wo_version = 1
tenant_id = var.tenant_id
}
}
}
# Connect the DEV workspace to Git.
resource "fabric_workspace_git" "dev" {
workspace_id = fabric_workspace.dev.id
initialization_strategy = "PreferRemote"
git_provider_details = {
git_provider_type = "AzureDevOps"
organization_name = var.ado_organization_name
# The Fabric API returns project/repository names lowercased. Pass them
# lowercased so Terraform's post-apply consistency check matches.
project_name = lower(var.ado_project_name)
repository_name = lower(var.ado_repository_name)
branch_name = var.ado_branch_name
directory_name = var.ado_directory_name
}
git_credentials = {
source = "ConfiguredConnection"
connection_id = fabric_connection.ado.id
}
}
# RBAC: grant the dev team Contributor on DEV.
# If contributor_principal_id is a security group rather than a user, change
# type to "Group".
resource "fabric_workspace_role_assignment" "dev_contributor" {
workspace_id = fabric_workspace.dev.id
role = "Contributor"
principal = {
id = var.contributor_principal_id
type = "User"
}
}
Deklaruj wyjścia
Stwórz outputs.tf. Nazwa testowego obszaru roboczego zasila etap wdrożenia.
output "dev_workspace_id" { value = fabric_workspace.dev.id }
output "test_workspace_id" { value = fabric_workspace.test.id }
output "test_workspace_name" {
description = "Pass this as --workspace_name to the fabric-cicd deploy step."
value = fabric_workspace.test.display_name
}
Stosowanie konfiguracji
Podaj wartości zmiennych (na przykład w pliku terraform.tfvars , który trzymasz poza Gitem), a następnie uruchom:
terraform init
terraform plan
terraform apply
Terraform raportuje zasoby, które stworzył, i drukuje wyniki.
Uwaga / Notatka
Punkt kontrolny. W portalu Fabric potwierdź, że przestrzenie releaseflow-dev robocze i releaseflow-test istnieją i są przypisane do Twojej pojemności.
Wyzwania związane z aprowizacją, o których warto wiedzieć
Dostawca Fabric oferuje duże możliwości, ale pewne mechanizmy działania mogą sprawiać użytkownikom trudność. Miej to na uwadze, zanim zaczniesz to produkować:
- Połączenie Git nie może zostać zaimportowane. Zasób
fabric_workspace_gitnie obsługujeterraform import. Traktuj to jako jednorazowy bootstrap i utrzymuj w trybie zdalnym, żeby późniejsze uruchomienia nie próbowały go odtwarzać. Przechowuj swój stan w współdzielonym backendzie, takim jak Azure Storage, zamiast na jednym laptopie. - Nazwy Git z rozróżnianiem wielkości liter. Fabric API zwraca nazwy projektów i repozytoriów Azure DevOps małymi literami. Jeśli zaliczysz je w mieszanych przypadkach, Terraform raportuje "dostawca uzyskał niespójny wynik po zastosowaniu." Owij je w
lower(), jak pokazano powyżej. - Zakres działania głównej usługi. To samo konto musi mieć możliwość tworzenia obszarów roboczych w tej pojemności i zostać dodane jako członek obszaru roboczego. Jeśli aprowizacja zakończy się niepowodzeniem z powodu błędu autoryzacji, ponownie sprawdź ustawienie dzierżawy i przypisanie roli dla pojemności w sekcji wymagania wstępne.
- Jeśli to możliwe, nie przechowuj sekretów w stanie. Sekret połączenia używa argumentu
client_secret_wo, który jest tylko do zapisu, więc nie jest przechowywany w stanie jawnym. Mimo to traktuj plik stanu jako dane wrażliwe.
Krok 2: Sprawdź połączenie Git
Terraform już połączył przestrzeń roboczą deweloperską z Gitem w kroku 1. Potwierdź to:
- W portalu Fabric otwórz obszar roboczy
releaseflow-dev. - Wybierz Ustawienia obszaru roboczego>Integracja z Git.
- Upewnij się, że przestrzeń robocza jest połączona z Twoją organizacją Azure DevOps, projektem, repozytorium, gałęzią oraz folderem, który ustawiłeś w
ado_directory_name.
Uwaga / Notatka
Punkt kontrolny. Obszar roboczy programisty wyświetla stan Kontrola źródła i jest zsynchronizowany z gałęzią określoną przez Ciebie.
Krok 3: Napisz treść w dev i commituj ją
Teraz dodaj zawartość do przestrzeni roboczej dewelopera i przepchnij ją do Gita. W tym samouczku tworzysz dwa przedmioty: domek nad jeziorem oraz zeszyt, który z niego czyta.
- W
releaseflow-dev, stwórz domek nad jeziorem o nazwie demoLakehouse. - Stwórz notatnik o nazwie demoNotebook. Dołącz
demoLakehousejako domyślny lakehouse i dodaj komórkę, która odczytuje tabelę lub zapisuje niewielki przykładowy DataFrame. - Uruchom notes raz, żeby potwierdzić, że działa przeciwko deweloperskiej chatce nad jeziorem.
- Otwórz Kontrola źródła w przestrzeni roboczej, wybierz oba elementy i zatwierdź je w swojej gałęzi.
Po commitcie twoje repozytorium zawiera demoLakehouse.Lakehouse folder oraz demoNotebook.Notebook folder pod katalogiem, który skonfigurowałeś.
Uwaga / Notatka
Punkt kontrolny. Panel Kontrola źródła wyświetla 0 oczekujących zmian po zatwierdzeniu, a foldery elementów pojawiają się w Azure DevOps.
Krok 4: Wdróż ze środowiska deweloperskiego do środowiska testowego za pomocą fabric-cicd
Przestrzeń robocza testu nadal jest pusta. Użyj fabric-cicd, aby opublikować elementy z Gita w środowisku testowym, po drodze ponownie wiążąc notes z testowym lakehouse’em.
Wskazówka
fabric-cicd to jeden ze sposobów wdrażania płaszczyzny danych. Jeśli wolisz samodzielnie skryptować wywołania REST, zobacz Tutorial: CI/CD z wykorzystaniem Fabric bulk API.
Zainstaluj fabric-cicd
Stwórz requirements.txt:
fabric-cicd>=0.1.20
azure-identity>=1.17.0
Zainstaluj ją:
pip install -r requirements.txt
Uwaga / Notatka
Fabric-CICD obsługuje Python 3.9 do 3.13. Zainstaluj go w środowisku wirtualnym, aby odizolować go od innych projektów.
Dodaj plik parametrów
Notatnik przechowywany w Gicie wskazuje na dom deweloperski nad jeziorem i miejsce pracy deweloperów . Podczas wdrażania testów te odniesienia muszą się zmieniać, aby notatnik odczytywał i zapisywał dane testowe. Fabric-CICD robi to za pomocą pliku parameter.yml .
Stwórz parameter.yml obok swojego skryptu wdrożenia. Zastąp dwa zastępcze identyfikatory GUID rzeczywistym identyfikatorem deweloperskiego obiektu Lakehouse i identyfikatorem deweloperskiego obszaru roboczego, które pojawiają się w zatwierdzonej zawartości twojego notesu:
find_replace:
# DEV lakehouse id -> the deployed demoLakehouse id in the target workspace.
- find_value: "<dev-lakehouse-guid>"
replace_value:
test: "$items.Lakehouse.demoLakehouse.$id"
item_type: "Notebook"
item_name: "demoNotebook"
file_path: "/demoNotebook.Notebook/notebook-content.py"
# DEV workspace id -> the target workspace id.
- find_value: "<dev-workspace-guid>"
replace_value:
test: "$workspace.$id"
item_type: "Notebook"
item_name: "demoNotebook"
file_path: "/demoNotebook.Notebook/notebook-content.py"
Tokeny $items.Lakehouse.demoLakehouse.$id and $workspace.$id są rozwiązywane przez fabric-cicd w momencie wdrożenia do GUIDów w docelowej przestrzeni roboczej.
Napisz skrypt wdrożenia
Stwórz deploy.py:
import argparse
from azure.identity import DefaultAzureCredential
from fabric_cicd import (
FabricWorkspace,
publish_all_items,
unpublish_all_orphan_items,
)
ITEM_TYPES = ["Lakehouse", "Notebook"]
def main() -> None:
p = argparse.ArgumentParser()
p.add_argument("--workspace_name", required=True)
p.add_argument("--environment", required=True)
p.add_argument("--repository_directory", default="./workspace")
p.add_argument("--parameter_file", default="./parameter.yml")
args = p.parse_args()
target = FabricWorkspace(
workspace_name=args.workspace_name,
environment=args.environment,
repository_directory=args.repository_directory,
item_type_in_scope=ITEM_TYPES,
parameter_file_path=args.parameter_file,
token_credential=DefaultAzureCredential(),
)
# Create or update every item, applying parameter.yml.
publish_all_items(target)
# Remove items deleted from the repo so test mirrors the branch.
unpublish_all_orphan_items(target)
print(f"Deployment to '{args.workspace_name}' complete.")
if __name__ == "__main__":
main()
Uruchom wdrożenie
Skieruj skrypt na nazwę przestrzeni roboczej testowej, którą Terraform wyświetlił jako .test_workspace_name Sklonuj repozytorium (lub użyj ponownie lokalnej kopii, którą skomitował deweloper), aby foldery elementów były dostępne lokalnie, a następnie uruchom:
python deploy.py \
--workspace_name releaseflow-test \
--environment test \
--repository_directory ./workspace \
--parameter_file ./parameter.yml
fabric-cicd tworzy lakehouse i notesnik w środowisku testowym, stosuje reguły find_replace i raportuje każdy opublikowany element.
Uwaga / Notatka
Punkt kontrolny. Polecenie wyświetla Deployment to 'releaseflow-test' complete. nie zgłaszając żadnych błędów.
Krok 5: Zweryfikowaj promocję
Potwierdź, że test otrzymał poprawnie odbitą kopię treści:
- W portalu Fabric otwórz obszar roboczy
releaseflow-test. - Potwierdź, że demoLakehouse i demoNotebook już istnieją.
- Otwórz demoNotebook i upewnij się, że jego domyślnym lakehouse’em jest test
demoLakehouse, a nie dev. - Uruchom notatnik. Powinien przeczytać i zapisać testowy domek nad jeziorem.
Uwaga / Notatka
Punkt kontrolny. Notatnik uruchamia test na testowym jeziorze, udowadniając, że fabric-cicd odbija referencje specyficzne dla środowiska.
Masz teraz powtarzalny cykl: zmień elementy w środowisku deweloperskim, zatwierdź zmiany w repozytorium Git, a następnie ponownie uruchom deploy.py, aby przenieść zmiany do środowiska testowego.
Automatyzuj w Azure DevOps
Wszystko, co uruchamiasz lokalnie, korzysta z tego samego principu usługi, co potok, więc przejście na CI/CD polega głównie na umieszczeniu tych poleceń w etapach potoku: jeden etap działa terraform apply (płaszczyzna sterowania), późniejszy deploy.py etap (plan danych). Aby uzyskać szczegółowy opis etapu wdrażania fabric-cicd w Azure Pipelines, w tym grup zmiennych i zatwierdzeń, zobacz Tutorial: CI/CD using Azure DevOps and the fabric-cicd library.
Przedłuż ten samouczek
Ten samouczek wykorzystuje notes i domek nad jeziorem. Ten sam wzorzec skaluje się na większą część płaszczyzny danych:
- Dodaj
SemanticModeliReportdoITEM_TYPESoraz dodaj regułęsemantic_model_bindingwparameter.yml, aby skierować modele do połączenia każdego środowiska. - Dodaj
VariableLibrary, a następnie pozwól, aby fabric-cicd aktywował zestaw wartości odpowiadający parametrowi--environment, który przekazujesz. - Dodaj krok po wdrożeniu (na przykład odświeżenie modelu semantycznego lub uruchomienie notesu do testów dymnych) po
publish_all_items.
Uprzątnij zasoby
Aby nie zużywać pojemności, usuń utworzone przez siebie przestrzenie robocze. Z twojego folderu Terraform:
terraform destroy
Alternatywnie usuń obszary robocze releaseflow-dev i releaseflow-test z portalu Fabric.
Treści powiązane
- Czym jest CI/CD w Microsoft Fabric?
- Opcje przepływu pracy CI/CD w Fabric
- Samouczek: CI/CD przy użyciu Azure DevOps i biblioteki fabric-cicd
- Samouczek: CI/CD z wykorzystaniem Fabric bulk API
- Tutorial: Zarządzanie cyklem życia aplikacji w Fabric
- Microsoft Fabric Terraform provider
- Dokumentacja biblioteki FABRIC-CICD