Distribuer Power BI-prosjekter (PBIP) ved bruk av fabric-cicd

Viktig!

Power BI Desktop-prosjekter er for øyeblikket i forhåndsversjon.

fabric-cicd er et Python-bibliotek utviklet av Microsoft som gir en kode-først-metode for Fabric-utviklere til å distribuere Fabric-elementer fra kildekontroll til arbeidsområder ved hjelp av deres kodedefinisjonsformat, som semantiske modeller og rapporter med PBIP-filformatet.

I denne artikkelen lærer du hvordan du:

Distribuer PBIP-filer manuelt fra din lokale maskin
Parameteriser PBIP-filer for miljøspesifikke konfigurasjoner
Automatiser distribusjoner med branch-based workspace targeting ved bruk av Azure DevOps eller GitHub Actions

Lær mer om PBIP-formatet i Power BI Desktop-prosjekter (PBIP) og oversikt over Fabric Git-integrasjon.

Hvorfor fabric-cicd for PBIP-distribusjon?

fabric-cicd er spesielt designet for distribusjon av kildekontrollerte Fabric-artefakter og tilbyr flere fordeler:

Bruker Fabric native REST API-er – Bygget på offisielle Microsoft Fabric API-er, som sikrer kompatibilitet og langsiktig støtte
Python-native – Sømløs integrasjon med moderne Python-baserte DevOps-arbeidsflyter
Parameterisering: Innebygd støtte for miljøspesifikke konfigurasjoner (arbeidsområde-IDer, datakilder, tilkoblingsstrenger)
Utviklervennlig: Enkle Python-skript som kan kjøres lokalt eller i CI/CD-pipelines
Fleksibel distribusjonskontroll: Distribuer kun spesifikke varetyper (f.eks. semantiske modeller uten rapporter, eller semantiske modeller med eller uten datacache) og sørg for konsistente konfigurasjoner som standardsider eller parametere uten manuell inngripen
Orphan-opprydding: Fjerner automatisk elementer fra arbeidsområdet som ikke lenger finnes i kildekodekontroll
Pålitelig autentisering: Bruker Azure Identity SDK med flere autentiseringsalternativer

Note

For fullstendig dokumentasjon, se fabric-cicd-dokumentasjonen.

Forutsetning

Før du begynner, må du sørge for at du har følgende:

Python (versjon 3.9 til 3.12)
Et Power BI Desktop-prosjekt lagret i PBIP-format
Tilgang til et Microsoft Fabric-arbeidsområde med bidragsyterrolle

For automatiserte utrullinger trenger du også:

En tjenesteprincipal med minst bidragsyter-rollen på mål-Fabric-arbeidsområder
Access to Azure DevOps eller GitHub Actions
Dine PBIP-filer i kildekode (Git, Azure DevOps eller GitHub)

Hurtigstart

Denne hurtigstarten viser deg hvordan du distribuerer et PBIP-prosjekt fra din lokale maskin til et Fabric-arbeidsområde.

1. Installer fabric-cicd

Åpne terminalen din og installer fabric-cicd:

pip install fabric-cicd

2. Forbered ditt PBIP-prosjekt

Sørg for at PBIP-prosjektet ditt inkluderer de nødvendige filene. En typisk PBIP-prosjektstruktur:

my-powerbi-project/
├── SalesAnalytics.Report/
│   ├── definition.pbir
│   └── definition/
│       └── pages/
├── SalesAnalytics.SemanticModel/
│   ├── definition.pbism
│   └── definition/
│       ├── model.tmdl
│       ├── tables/
│       └── ...
└── SalesAnalytics.pbip

For detaljert informasjon om nødvendige filer og formater, se Power BI Desktop prosjektrapportmappe og Power BI Desktop prosjekt semantiske modellmappe.

Tip

For å opprette et PBIP-prosjekt, åpne PBIX-filen din i Power BI Desktop og lagre den med > File Save As > Power BI Project (.pbip). Se Power BI Desktop-prosjekter for mer informasjon.

3. Lag deployeringsskript

Opprett en deploy.py fil i prosjektmappen din:

import argparse
import sys
from azure.identity import InteractiveBrowserCredential, AzureCliCredential
from fabric_cicd import FabricWorkspace, publish_all_items

parser = argparse.ArgumentParser(description="Deploy PBIP to Fabric")
parser.add_argument("--workspace_id", type=str, required=True, help="Target workspace ID")
parser.add_argument("--environment", type=str, default="dev", help="Environment name")
args = parser.parse_args()

# Use AzureCliCredential in CI/CD, fall back to InteractiveBrowserCredential for local
try:
    credential = AzureCliCredential()
except Exception:
    credential = InteractiveBrowserCredential()

workspace_params = {
    "workspace_id": args.workspace_id,
    "environment": args.environment,
    "repository_directory": ".",
    "item_type_in_scope": ["SemanticModel", "Report"],
    "token_credential": credential,
}

target_workspace = FabricWorkspace(**workspace_params)
publish_all_items(target_workspace)

4. Utplasser

Kjør distribusjonsskriptet med arbeidsplass-ID-en din:

python deploy.py --workspace_id "11111111-1111-1111-1111-111111111111"

Nettleseren din åpner for autentisering. Etter innlogging distribuerer fabric-cicd PBIP-filene dine til målarbeidsområdet. Du ser fremdriftsmeldinger som:

[info] Publishing SemanticModel 'SalesAnalytics'
       Operation in progress. Checking again in 1 second (Attempt 1)...
       Published

[info] Publishing Report 'SalesAnalytics'
       Published

Utrullingen tar vanligvis 20-30 sekunder, avhengig av størrelsen på din semantiske modell.

Note

Første gang du distribuerer en semantisk modell med datakilder, må du manuelt konfigurere datakilde-legitimasjoner i Fabric-portalen. Gå til workspace > semantic model > Settings Data > source credentials. Påfølgende distribusjoner gjenbruker de lagrede legitimasjonene.

Miljøspesifikk parameterisering

En av fabric-cicds kraftigste funksjoner er muligheten til å parameterisere PBIP-filene dine for ulike miljøer. Dette er essensielt når dine semantiske modeller refererer til miljøspesifikke ressurser som arbeidsområde-ID-er, lakehouse-ID-er eller tilkoblingsstrenger.

Eksempel: Parameteriser arbeidsområde- og lakehouse-ID-er

Opprett en parameter.yml fil i prosjektroten for å definere miljøspesifikke verdier:

find_replace:
  # Replace workspace ID for DirectLake connection
  - find_value: "11111111-1111-1111-1111-111111111111"
    replace_value:
      dev: "11111111-1111-1111-1111-111111111111"  # Dev workspace
      prod: "22222222-2222-2222-2222-222222222222"  # Prod workspace

  # Replace lakehouse ID for DirectLake semantic model
  - find_value: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
    replace_value:
      dev: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"  # Dev lakehouse
      prod: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"  # Prod lakehouse

Når du kjører python deploy.py --workspace_id "11111111-1111-1111-1111-111111111111" --environment dev, fabric-cicd automatisk:

Leser parameter.yml-filen
Finner alle instanser av find_value i dine PBIP-definisjonsfiler
Erstatter dem med den tilsvarende miljøspesifikke replace_value
Distribuerer de modifiserte definisjonene til målarbeidsområdet

Automatiser utrulling

Du kan automatisere PBIP-distribusjoner slik at de kjøres hver gang kode slås sammen med spesifikke grener i repositoriet ditt. Automatiseringen følger denne logikken:

En pipeline eller arbeidsflyt utløses når kode pushes til en konfigurert gren (f.eks. dev eller main)
Grennavnet bestemmer målmiljøet og arbeidsområdets ID
Distribusjonsskriptet kjører automatisk med de riktige parameterne
Dine PBIP-artefakter distribueres til riktig arbeidsområde for det miljøet

Denne seksjonen dekker oppsettstrinn som er felles for både Azure DevOps og GitHub Actions, etterfulgt av plattformspesifikke konfigurasjonsinstruksjoner.

Definer

Før du konfigurerer CI/CD-plattformen din, fullfør du disse vanlige oppsettstegene:

1. Opprette en tjenesteprinsipp

Opprett en tjenesteprincipal i Azure AD med bidragsyter eller administratorrolle på dine Fabric-arbeidsområder.

2. Legg til tjenesteprinsipp i Fabric-arbeidsområder

Åpne Fabric-portalen og naviger til hvert målarbeidsområde (utvikler, produksjon)
Gå til Arbeidsområdeinnstillinger > Administrer tilgang
Legg til tjenesteprincipalen med rollen som bidragsyter eller administrator

Note

Tjenesteprinsipper må aktiveres på leietakernivå for å bruke Fabric-API-er. For mer informasjon, se Service Principals can call Fabric public APIs.

3. Konfigurer grener i repositoriet ditt

Lag grenene du skal bruke til automatisering. For eksemplene i denne artikkelen:

Opprett en dev gren for utviklingsmiljødistribusjon
Lag en main gren for distribusjon av produksjonsmiljøer

Du kan tilpasse grennavn og legge til flere miljøer ved å endre arbeidsområdets kartlegging i YAML-filene.

Azure DevOps

Automatiser PBIP-distribusjoner med Azure Pipelines. Når kode pushes til konfigurerte grener, distribueres pipelinen automatisk til det tilsvarende arbeidsområdet.

Opprett azure-pipelines.yml roten i repositoriet ditt:

trigger:
  branches:
    include:
      - dev
      - main

variables:
  - name: workspace_ids
    value: |
      {
        "dev": "11111111-1111-1111-1111-111111111111",
        "main": "22222222-2222-2222-2222-222222222222"
      }
  - name: environments
    value: |
      {
        "dev": "dev",
        "main": "prod"
      }

stages:
  - stage: Deploy
    jobs:
      - job: DeployPBIP
        pool:
          vmImage: 'windows-latest'
        steps:
          - checkout: self
          - task: UsePythonVersion@0
            inputs:
              versionSpec: '3.12'
              addToPath: true
          - task: AzureCLI@2
            displayName: 'Deploy PBIP to Fabric'
            inputs:
              azureSubscription: 'your-azure-service-connection'
              scriptType: 'ps'
              scriptLocation: 'inlineScript'
              inlineScript: |
                cd "$(Build.SourcesDirectory)"
                
                pip install fabric-cicd
                
                $branch_ref = $env:BUILD_SOURCEBRANCH
                $branch_name = $branch_ref -replace '^refs/heads/', ''
                
                $workspace_ids = '$(workspace_ids)' | ConvertFrom-Json
                $environments = '$(environments)' | ConvertFrom-Json
                
                $workspace_id = $workspace_ids.$branch_name
                $environment = $environments.$branch_name
                
                python -u deploy.py --workspace_id "$workspace_id" --environment "$environment"
                
                if ($LASTEXITCODE -ne 0) {
                    Write-Error "Deployment failed with exit code: $LASTEXITCODE"
                    exit $LASTEXITCODE
                }

Configure Azure DevOps

Create an Azure service connection in Azure DevOps project settings:
- Gå til Prosjektinnstillinger > Tjenesteforbindelser
- Opprett en ny Azure Resource Manager-tjenestetilkobling ved å bruke dine tjenesteprincipal-legitimasjoner
- For detaljerte instruksjoner, se Connect to Microsoft Azure
- Oppdater azureSubscription verdien i YAML slik at den matcher tjenesteforbindelsens navn
Oppdater arbeidsområdets ID-er i YAML:
- Rediger variabelen workspace_ids i azure-pipelines.yml
- Sett utvikler- og produksjonsarbeidsområde-IDene dine
- Commit og push endringene til ditt repositorium
Lag pipelinen:
- Gå til Rørledninger > Ny rørledning
- Velg ditt repositorium og velg "Existing Azure Pipelines YAML file"
- Velg azure-pipelines.yml
- For detaljerte instruksjoner, se Lag din første pipeline
- Lagre og kjør pipelinen for å distribuere PBIP-en din til Fabric

GitHub-handlinger

Automatiser PBIP-distribusjoner med GitHub Actions. Når kode pushes til konfigurerte grener, distribueres arbeidsflyten automatisk til det tilsvarende arbeidsområdet.

Opprett .github/workflows/deploy.yml i ditt arkiv:

name: Deploy PBIP to Fabric

on:
  push:
    branches: [dev, main]
  workflow_dispatch:

jobs:
  deploy:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v3
      
      - uses: actions/setup-python@v4
        with:
          python-version: '3.12'
      
      - name: Set workspace variables
        id: workspace
        shell: pwsh
        run: |
          $branch_name = "${{ github.ref_name }}"
          
          $workspace_ids = @{
            "dev" = "11111111-1111-1111-1111-111111111111"
            "main" = "22222222-2222-2222-2222-222222222222"
          }
          
          $environments = @{
            "dev" = "dev"
            "main" = "prod"
          }
          
          $workspace_id = $workspace_ids[$branch_name]
          $environment = $environments[$branch_name]
          
          echo "workspace_id=$workspace_id" >> $env:GITHUB_OUTPUT
          echo "environment=$environment" >> $env:GITHUB_OUTPUT
      
      - name: Azure Login
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}
      
      - name: Deploy PBIP to Fabric
        shell: pwsh
        run: |
          pip install fabric-cicd
          
          python -u deploy.py --workspace_id "${{ steps.workspace.outputs.workspace_id }}" --environment "${{ steps.workspace.outputs.environment }}"
          
          if ($LASTEXITCODE -ne 0) {
              Write-Error "Deployment failed with exit code: $LASTEXITCODE"
              exit $LASTEXITCODE
          }

Konfigurer GitHub-handlinger

Create Azure credentials secret:
- Få dine tjenesteleder-kvalifikasjoner i JSON-format:
```
{
  "clientId": "<service-principal-client-id>",
  "clientSecret": "<service-principal-secret>",
  "subscriptionId": "<azure-subscription-id>",
  "tenantId": "<azure-tenant-id>"
}
```
- Gå til GitHub-repositoriet Innstillinger > Hemmeligheter og variabler Handlinger >
- Legg til AZURE_CREDENTIALS med JSON-en ovenfor
Oppdater arbeidsområdets ID-er i arbeidsflyten:
- Rediger workspace_ids hashtabellen i steget «Sett arbeidsområdevariabler» i .github/workflows/deploy.yml
- Sett utvikler- og produksjonsarbeidsområde-IDene dine
- Commit og push arbeidsflyt-YAML til ditt repository

Tilbakemeldinger

Var denne siden nyttig?

Last updated on 2026-01-23

Del via

Distribuer Power BI-prosjekter (PBIP) ved bruk av fabric-cicd

Hvorfor fabric-cicd for PBIP-distribusjon?

Forutsetning

Hurtigstart

1. Installer fabric-cicd

2. Forbered ditt PBIP-prosjekt

3. Lag deployeringsskript

4. Utplasser

Miljøspesifikk parameterisering

Eksempel: Parameteriser arbeidsområde- og lakehouse-ID-er

Automatiser utrulling

Definer

1. Opprette en tjenesteprinsipp

2. Legg til tjenesteprinsipp i Fabric-arbeidsområder

3. Konfigurer grener i repositoriet ditt

Azure DevOps

Configure Azure DevOps

GitHub-handlinger

Konfigurer GitHub-handlinger

Relatert innhold

Tilbakemeldinger

Flere ressurser