Automatisera Git-integrering med hjälp av API:er

2025-09-10

Med Microsoft Fabric Git-integreringsverktyget kan team arbeta tillsammans med källkontroll för att skapa en effektiv och återanvändbar lanseringsprocess för sitt Fabric-innehåll.

Med Rest-API:er för Microsoft Fabric kan du automatisera Fabric-procedurer och -processer för att utföra uppgifter snabbare och med färre fel. Den här effektiviteten leder till kostnadsbesparingar och förbättrad produktivitet.

I den här artikeln beskrivs hur du använder REST-API:er för Git-integrering för att automatisera Git-integrering i Microsoft Fabric.

Prerequisites

För att arbeta med Fabric Git-API:er behöver du:

Samma krav som du behöver för att använda Git-integrering i användargränssnittet.
En Microsoft Entra-token för Fabric-tjänsten. Använd den token i auktoriseringshuvudet för API-anropet. Information om hur du hämtar en token finns i Snabbstart för Infrastruktur-API.
Om du använder ett huvudnamn för tjänsten behöver det samma behörigheter som ett användarhuvudnamn. Information om hur du konfigurerar ett huvudnamn för tjänsten för Azure DevOps finns i Git-integrering med tjänstens huvudnamn.

Du kan använda REST-API:er utan PowerShell, men skripten i den här artikeln använder PowerShell. Utför följande steg för att köra skripten:

Installera PowerShell.
Installera Azure PowerShell Az-modulen.

Api-funktioner för Git-integrering

Rest-API:er för Git-integrering kan hjälpa dig att uppnå kontinuerlig integrering och kontinuerlig leverans (CI/CD) av ditt innehåll. Här följer några exempel på vad som kan göras med hjälp av API:erna:

Anslut och koppla från en specifik arbetsyta från Git-lagringsplatsen och grenen som är ansluten till den. (Connect kräver connectionId för autentiseringsuppgifterna för Git-providern.)
Hämta anslutningsinformation för den angivna arbetsytan.
Hämta eller skapa en anslutning för autentiseringsuppgifter för Git-providern.
Uppdatera mina Git-autentiseringsuppgifter för att uppdatera konfigurationsinformationen för Dina Git-autentiseringsuppgifter. Kräver connectionId för autentiseringsuppgifterna för Git-providern.
Hämta mina Git-autentiseringsuppgifter för att hämta konfigurationsinformation för Git-autentiseringsuppgifter.
Initiera en anslutning för en arbetsyta som är ansluten till Git.
Se vilka objekt som har inkommande ändringar och vilka objekt som har ändringar som ännu inte har checkats in till Git med Git-status-API:et.
Kommitta ändringarna som gjorts i arbetsytan till den kopplade fjärrgrenen.
Uppdatera arbetsytan med incheckningar som skickas till den anslutna grenen.

Examples

Använd följande PowerShell-skript för att förstå hur du utför flera vanliga automatiseringsprocesser. Om du vill visa eller kopiera texten i ett PowerShell-exempel använder du länkarna i det här avsnittet. Du kan också se alla exempel i Git-integreringsexemplen för Fabric GitHub-lagringsplatsen.

Ansluta och uppdatera

I det här avsnittet beskrivs stegen för att ansluta och uppdatera en arbetsyta med Git.

Det fullständiga skriptet finns i Ansluta och uppdatera från Git. (Skriptkompatibiliteten är PowerShell 5.1)

Anslut till Azure-konto och hämta åtkomsttoken – Logga in på Fabric som en användare eller tjänstens huvudkonto. Använd kommandot Connect-AzAccount för att ansluta. Om du vill hämta en åtkomsttoken använder du kommandot Get-AzAccessToken och konverterar den säkra strängtoken till oformaterad text

Koden bör se ut ungefär så här:

Användarens huvudnamn
Tjänstens huvudnamn

 $global:resourceUrl = "https://api.fabric.microsoft.com"

 $global:fabricHeaders = @{}

 function SetFabricHeaders() {

    #Login to Azure
    Connect-AzAccount | Out-Null

    # Get authentication
    $secureFabricToken = (Get-AzAccessToken -AsSecureString -ResourceUrl $global:resourceUrl).Token

    # Convert secure string to plain test
    $ssPtr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureFabricToken)
    try {
        $fabricToken = [System.Runtime.InteropServices.Marshal]::PtrToStringBSTR($ssPtr)
    } finally {
        [System.Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ssPtr)
   }

  $global:fabricHeaders = @{
     'Content-Type' = "application/json"
     'Authorization' = "Bearer {0}" -f $fabricToken
 }
}

$global:resourceUrl = "https://api.fabric.microsoft.com"
$global:fabricHeaders = @{}

function SetFabricHeaders() {

   $clientId = "<CLIENT ID>"
   $tenantId = "<TENANT ID>"
   $secret = "<SECRET VALUE>"

   $secureSecret  = ConvertTo-SecureString -String $secret -AsPlainText -Force
   $credential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $clientId, $secureSecret

   #Login to Azure using service principal
   Connect-AzAccount -ServicePrincipal -TenantId $tenantId -Credential $credential | Out-Null

   # Get authentication
   $secureFabricToken = (Get-AzAccessToken -AsSecureString -ResourceUrl $global:resourceUrl).Token

   # Convert secure string to plain text
   $ssPtr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureFabricToken)
   try {
       $fabricToken = [System.Runtime.InteropServices.Marshal]::PtrToStringBSTR($ssPtr)
   } finally {
      [System.Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ssPtr)
   }

  $global:fabricHeaders = @{
     'Content-Type' = "application/json"
     'Authorization' = "Bearer {0}" -f $fabricToken
  }
}

Anropa Connect-API:et för att ansluta arbetsytan till en Git-lagringsplats och -gren. (du kan behöva skapa en anslutning först)

Information om hur du hämtar anslutningsinformation (ID, namn) finns i Hämta eller skapa anslutning för autentiseringsuppgifter för Git-provider.

Azure DevOps
GitHub (användarens eller tjänstens huvudnamn)

$global:baseUrl = "https://api.fabric.microsoft.com/v1"
$workspaceName = "<WORKSPACE NAME>"
$getWorkspacesUrl = "{0}/workspaces" -f $global:baseUrl
$workspaces = (Invoke-RestMethod -Headers $global:fabricHeaders -Uri $getWorkspacesUrl -Method GET).value

# Find the workspace by display name
$workspace = $workspaces | Where-Object {$_.DisplayName -eq $workspaceName}

# Connect to Git
Write-Host "Connecting the workspace '$workspaceName' to Git."
$connectUrl = "{0}/workspaces/{1}/git/connect" -f $global:baseUrl, $workspace.Id

# AzureDevOps details
$azureDevOpsDetails = @{
    gitProviderType = "AzureDevOps"
    organizationName = "<ORGANIZATION NAME>"
    projectName = "<PROJECT NAME>"
    repositoryName = "<REPOSITORY NAME>"
    branchName = "<BRANCH NAME>"
    directoryName = "<DIRECTORY NAME>"
}

$connectToGitBody = @{}
#Leave only one of the following two (delete the other one):
#-----------------------------------------------------------------------------------------------
# 1. Automatic (SSO)
$connectToGitBody = @{
    gitProviderDetails = $gitProviderDetails
} | ConvertTo-Json
#-----------------------------------------------------------------------------------------------
# 2. ConfiguredConnection (User or service principal)
# Get workspaces
$connectionName = "<CONNECTION Name>"
$getConnectionsUrl = "{0}/connections" -f $global:baseUrl
$connections = (Invoke-RestMethod -Headers $global:fabricHeaders -Uri $getConnectionsUrl -Method GET).value

# Find the connection by display name
$connection = $connections | Where-Object {$_.DisplayName -eq $connectionName}
$connectToGitBody = @{
    gitProviderDetails = $azureDevOpsDetails
    myGitCredentials = @{
        source = "ConfiguredConnection"
        connectionId = $connection.id
        }
    } | ConvertTo-Json
#-----------------------------------------------------------------------------------------------

Invoke-RestMethod -Headers $global:fabricHeaders -Uri $connectUrl -Method POST -Body $connectToGitBody

Information om hur du hämtar anslutnings-ID:t finns i Hämta eller skapa autentiseringsuppgifter för Git-providern.

$global:baseUrl = "https://api.fabric.microsoft.com/v1"
$workspaceName = "<WORKSPACE NAME>"
$getWorkspacesUrl = "{0}/workspaces" -f $global:baseUrl 
$workspaces = (Invoke-RestMethod -Headers $global:fabricHeaders -Uri $getWorkspacesUrl -Method GET).value

# Find the workspace by display name
$workspace = $workspaces | Where-Object {$_.DisplayName -eq $workspaceName}

# Connect to Git
Write-Host "Connecting the workspace '$workspaceName' to Git."

$connectUrl = "{0}/workspaces/{1}/git/connect" -f $global:baseUrl, $workspace.Id

# GitHub details
$gitHubDetails = @{
    gitProviderType = "GitHub"
    ownerName = "<OWNER NAME>"
    repositoryName = "<REPOSITORY NAME>"
    branchName = "<BRANCH NAME>"
    directoryName = "<DIRECTORY NAME>"
}

$connectionName = "<CONNECTION Name>"

# Get connections 
$getConnectionsUrl = "$global:baseUrl/connections"
$connections = (Invoke-RestMethod -Headers $global:fabricHeaders -Uri $getConnectionsUrl -Method GET).value

# Find the connection by name
$connection = $connections | Where-Object {$_.DisplayName -eq $connectionName}

$connectToGitBody = @{
    gitProviderDetails = $gitHubDetails
    myGitCredentials = @{
        source = "ConfiguredConnection"
        connectionId = $connection.id
    }
} | ConvertTo-Json

Invoke-RestMethod -Headers $global:fabricHeaders -Uri $connectUrl -Method POST -Body $connectToGitBody

Anropa API:et Initiera anslutning för att initiera anslutningen mellan arbetsytan och Git-lagringsplatsen/grenen.

# Initialize Connection

Write-Host "Initializing Git connection for workspace '$workspaceName'."

$initializeConnectionUrl = "{0}/workspaces/{1}/git/initializeConnection" -f $global:baseUrl, $workspace.Id
$initializeConnectionResponse = Invoke-RestMethod -Headers $global:fabricHeaders -Uri $initializeConnectionUrl -Method POST -Body "{}"

Baserat på svaret från API:et Initiera anslutning anropar du antingen Uppdatering från Git-API :et för att slutföra uppdateringen eller gör ingenting om ingen åtgärd krävs.

Följande skript uppdaterar och övervakar förloppet:

if ($initializeConnectionResponse.RequiredAction -eq "UpdateFromGit") {

    # Update from Git
    Write-Host "Updating the workspace '$workspaceName' from Git."

    $updateFromGitUrl = "{0}/workspaces/{1}/git/updateFromGit" -f $global:baseUrl, $workspace.Id

    $updateFromGitBody = @{ 
        remoteCommitHash = $initializeConnectionResponse.RemoteCommitHash
  workspaceHead = $initializeConnectionResponse.WorkspaceHead
    } | ConvertTo-Json

    $updateFromGitResponse = Invoke-WebRequest -Headers $global:fabricHeaders -Uri $updateFromGitUrl -Method POST -Body $updateFromGitBody

    $operationId = $updateFromGitResponse.Headers['x-ms-operation-id']
    $retryAfter = $updateFromGitResponse.Headers['Retry-After']
    Write-Host "Long Running Operation ID: '$operationId' has been scheduled for updating the workspace '$workspaceName' from Git with a retry-after time of '$retryAfter' seconds." -ForegroundColor Green

    # Poll Long Running Operation
    $getOperationState = "{0}/operations/{1}" -f $global:baseUrl, $operationId
    do
    {
        $operationState = Invoke-RestMethod -Headers $global:fabricHeaders -Uri $getOperationState -Method GET

        Write-Host "Update from Git operation status: $($operationState.Status)"

        if ($operationState.Status -in @("NotStarted", "Running")) {
            Start-Sleep -Seconds $retryAfter
        }
    } while($operationState.Status -in @("NotStarted", "Running"))
}

Uppdatera från Git

I det här avsnittet beskriver vi stegen för att uppdatera en arbetsyta med ändringarna från Git. I det här skriptet uppdaterar vi arbetsyteobjekten med ändringar från Git, men vi lämnar Git-lagringsplatsen oförändrad.

Det fullständiga skriptet finns i Uppdatera arbetsyta från Git.

Logga in på Git och hämta autentisering.
Anropa API:et Hämta status för att skapa uppdateringen från Git-begärandetexten.
Anropa Update From Git-API:et för att uppdatera arbetsområdet med commits som skickas till den anslutna grenen.

Förplikta alla

Det här avsnittet innehåller en stegvis beskrivning av hur du programmatiskt genomför alla ändringar från arbetsytan till Git.

Det fullständiga skriptet finns i Checka in alla ändringar i Git.

Logga in på Git och hämta autentisering.
Anslut till arbetsytan.
Anropa Commit to Git REST API.
Hämta Long Running OperationId för att förfråga status för operationen.

Selektiv commit

I det här avsnittet beskrivs de steg som ingår i att endast utföra specifika ändringar från arbetsytan till Git.

För det fullständiga skriptet, se Sammanfoga valda ändringar i Git.

Logga in på Git och hämta autentisering.
Anslut till arbetsytan.
Anropa API:et Hämta status för att se vilka objekt som ändrats i arbetsytan.
Välj de specifika objekt som ska bekräftas.
Kalla API:et Commit to Git för att begå de valda ändringarna från arbetsområdet till den anslutna fjärrgrenen.

Övervaka förloppet för tidskrävande åtgärder

Det fullständiga skriptet finns i Kontrollera status för en långvarig operation.

Hämta operationId från Uppdatera från Git eller Commit till Git skriptet.
Anropa API:et Hämta LRO-status med angivna intervall (i sekunder) och skriv ut statusen.

Hämta eller skapa anslutning för autentiseringsuppgifter för Git-provider

För att kunna ansluta till en Git-lagringsplats eller uppdatera dina Git-autentiseringsuppgifter måste du ange ett connectionId. ConnectionId kan komma från antingen en ny anslutning som du skapar eller en befintlig anslutning.

Skapa en ny anslutning med dina autentiseringsuppgifter för Git-providern
Använd en befintlig anslutning som du har behörighet för.

Skapa en ny anslutning som lagrar dina Git-autentiseringsuppgifter

Azure DevOps (förhandsversion)
GitHub

Följande kodfragment visar en exempelbegärandetext för att skapa en anslutning som lagrar dina Azure DevOps-autentiseringsuppgifter. Det fullständiga exemplet finns i Fabric samples-repo.

# Connection with ServicePrincipal details for AzureDevOpsSourceControl
$adoSPConnection = @{
    connectivityType = "ShareableCloud"
    displayName = "<CONNECTION NAME>"
    connectionDetails = @{
        type = "AzureDevOpsSourceControl"
        creationMethod = "AzureDevOpsSourceControl.Contents"
        parameters = @(
            @{
                dataType = "Text"
                name = "url"
                value = "<Repo url in Azure DevOps>"
            }
        )
    }
    credentialDetails = @{
        credentials = @{
            credentialType = "ServicePrincipal"
            tenantId = "<SP tenant (directory) id (Guid)>"
            servicePrincipalClientId = "<SP APP (client) id (Guid)>"
            servicePrincipalSecret = "<SP Secret>"
        }
    }
}

#Note: AzureDevOps for UserPrincipal is not supported (since it requires interactive OAuth2)

Exempelbegäran

POST https://api.fabric.microsoft.com/v1/connections

{
  "displayName": "<CONNECTION NAME>",
  "connectivityType": "ShareableCloud",
  "connectionDetails": {
    "creationMethod": "AzureDevOpsSourceControl.Contents",
    "type": "AzureDevOpsSourceControl",
    "parameters": [
     {
      "dataType": "Text",
      "name": "url",
      "value": "<Repo url in Azure DevOps>”
     }
    ]
  },
  "credentialDetails": {
    "credentials": {
      "credentialType": "ServicePrincipal",
      "tenantId": “<SP tenant (directory) id (Guid)>”,
      "servicePrincipalClientId": “<SP APP (client) id (Guid)>”,
      "servicePrincipalSecret": “<SP Secret>”
    }
  }
}

Exempelsvar:

{
  "allowConnectionUsageInGateway": false,
  "id": "********-****-****-****-c13b543982ac",
  "displayName": "<CONNECTION NAME>",
  "connectivityType": "ShareableCloud",
  "connectionDetails": {
    "path": "<Repo url in Azure DevOps>",
    "type": "AzureDevOpsSourceControl"
  },
  "privacyLevel": "Organizational",
  "credentialDetails": {
    "credentialType": "ServicePrincipal",
    "singleSignOnType": "None",
    "connectionEncryption": "NotEncrypted",
    "skipTestConnection": false
  }
}

Använd din personliga åtkomsttoken (PAT) för att skapa en GitHub-anslutning.

Om du anger namnet på en specifik lagringsplats begränsas anslutningen till lagringsplatsen. Om du inte anger namnet på någon lagringsplats får du åtkomst till alla lagringsplatser som du har behörighet för.

Om du vill skapa en anslutning som lagrar dina GitHub-autentiseringsuppgifter anropar du API:et Skapa anslutning med följande begärandetext. Avsnittet parametrar är valfritt och behövs bara om du vill att anslutningen ska begränsas till en specifik lagringsplats.

Exempelbegäran

POST https://api.fabric.microsoft.com/v1/connections

{
 "connectivityType": "ShareableCloud",
 "displayName": "MyGitHubPAT",
 "connectionDetails": {
  "type": "GitHubSourceControl",
  "creationMethod": "GitHubSourceControl.Contents",
  "parameters": [
   {
    "dataType": "Text",
    "name": "url",
    "value": "https://github.com/OrganizationName/RepositoryName"
   }
  ]
 },
 "credentialDetails": {
  "credentials": {
   "credentialType": "Key",
   "key": "*********"  //Enter your GitHub Personal Access Token
  }
 }
}

Exempelsvar:

{
  "id": "3aba8f7f-d1ba-42b1-bb41-980029d5a1c1",
   "connectionDetails": {
       "path": "https://github.com/OrganizationName/RepositoryName",
       "type": "GitHubSourceControl"
   },
   "connectivityType": "ShareableCloud",
   "credentialDetails": {
       "connectionEncryption": "NotEncrypted",
       "credentialType": "Key",
       "singleSignOnType": "None",
       "skipTestConnection": false
   },
   "displayName": "MyGitHubPAT",
   "gatewayId": null,
   "privacyLevel": "Organizational"
}

Kopiera ID:t och använd det i API:et Git – Anslut eller Git – Uppdatera Mina Git-autentiseringsuppgifter .

Hämta en lista över befintliga anslutningar

Använd API:et Listanslutningar för att hämta en lista över befintliga anslutningar som du har behörighet för och deras egenskaper.

Exempelbegäran

GET https://api.fabric.microsoft.com/v1/connections

Exempelsvar

{
 "value": [
  {
   "id": "e3607d15-6b41-4d11-b8f4-57cdcb19ffc8",
   "displayName": "MyGitHubPAT1",
   "gatewayId": null,
   "connectivityType": "ShareableCloud",
   "connectionDetails": {
    "path": "https://github.com",
    "type": "GitHubSourceControl"
   },
   "privacyLevel": "Organizational",
   "credentialDetails": {
    "credentialType": "Key",
    "singleSignOnType": "None",
    "connectionEncryption": "NotEncrypted",
    "skipTestConnection": false
   }
  },
  {
   "id": "3aba8f7f-d1ba-42b1-bb41-980029d5a1c1",
   "displayName": "MyGitHubPAT2",
   "gatewayId": null,
   "connectivityType": "ShareableCloud",
   "connectionDetails": {
    "path": "https://github.com/OrganizationName/RepositoryName",
    "type": "GitHubSourceControl"
   },
   "privacyLevel": "Organizational",
   "credentialDetails": {
    "credentialType": "Key",
    "singleSignOnType": "None",
    "connectionEncryption": "NotEncrypted",
    "skipTestConnection": false
   }
  }
 ]
}

Kopiera ID:t för den anslutning som du vill använda och använd det i API:et Git – Anslut eller Git – Uppdatera mina Git-autentiseringsuppgifter .

Beaktanden och begränsningar

Git-integrering med API:er omfattas av samma begränsningar som användargränssnittet för Git-integrering.
Om du uppdaterar en semantisk modell med hjälp av API:et för förbättrad uppdatering orsakas en Git-diff efter varje uppdatering.

Feedback

Var den här sidan till hjälp?