Del via

Automatiser Git-integrering ved hjelp av API-er

Microsoft Fabric Git-integreringsverktøyet gjør det mulig for team å samarbeide ved hjelp av kildekontroll for å bygge en effektiv og gjenbrukbar utgivelsesprosess for Fabric-innholdet.

Med REST-API-er for Microsoft Fabric kan du automatisere Fabric-prosedyrer og -prosesser for å fullføre oppgaver raskere og med færre feil. Denne effektiviteten fører til kostnadsbesparelser og forbedret produktivitet.

Denne artikkelen beskriver hvordan du bruker REST-API-ene for Git-integrering til å automatisere Git-integrering i Microsoft Fabric.

Prerequisites

Hvis du vil arbeide med Fabric Git API-er, trenger du:

Du kan bruke REST-API-ene uten PowerShell, men skriptene i denne artikkelen bruker PowerShell. Hvis du vil kjøre skriptene, gjør du følgende:

API-funksjoner for Git-integrering

REST-API-ene for Git-integrering kan hjelpe deg med å oppnå kontinuerlig integrering og kontinuerlig levering (CI/CD) av innholdet. Her er noen eksempler på hva som kan gjøres ved hjelp av API-ene:

Examples

Bruk følgende PowerShell-skript til å forstå hvordan du utfører flere vanlige automatiseringsprosesser. Hvis du vil vise eller kopiere teksten i et PowerShell-eksempel, bruker du koblingene i denne inndelingen. Du kan også se alle eksemplene i Git-integreringseksemplet for Fabric GitHub.

Koble til og oppdatere

Denne delen beskriver trinnene som er involvert i å koble til og oppdatere et arbeidsområde med Git.

Hvis du vil ha det fullstendige skriptet, kan du se Koble til og oppdatere fra Git. (Skriptkompatibiliteten er PowerShell 5.1)

  1. Koble til Azure-konto og få tilgangstoken – Logg på Fabric som en bruker eller en tjenestekontohaver. Bruk kommandoen Connect-AzAccount til å koble til. Hvis du vil ha et tilgangstoken, bruker du kommandoen Get-AzAccessToken og konverterer tokenet for sikker streng til ren tekst

    Koden skal se omtrent slik ut:

     $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
 }
}

  2. Kall Connect-API-en for å koble arbeidsområdet til et Git-repositorium og en gren. (du må kanskje opprette en tilkobling først)

    Hvis du vil ha informasjon om hvordan du henter tilkoblingsdetaljene (ID, navn), kan du se Hent eller opprett Git-leverandørlegitimasjonstilkobling.

    $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

  3. Kall API-en Initialiser tilkobling for å initialisere tilkoblingen mellom arbeidsområdet og Git-repositoriet/-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 "{}"

  4. Basert på svaret fra API-en for Initialiser tilkobling, kan du kalle enten Oppdater fra Git-API-en for å fullføre oppdateringen, eller ikke gjøre noe hvis det ikke kreves noen handling.

    Følgende skript oppdaterer og overvåker fremdriften:

    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"))
}

Oppdater fra Git

I denne delen beskriver vi trinnene som er involvert i å oppdatere et arbeidsområde med endringene fra Git. I dette skriptet oppdaterer vi arbeidsområdeelementene med endringer fra Git, men vi lar Git-repositoriet være uendret.

Hvis du vil ha det fullstendige skriptet, kan du se Oppdatere arbeidsområde fra Git.

  1. Logg på Git, og få godkjenning.
  2. Kall API-en for hent status for å bygge oppdateringen fra Git-forespørselsteksten.
  3. Kall Oppdater fra Git-API-en for å oppdatere arbeidsområdet med utføringer sendt til den tilkoblede grenen.

Forplikt deg til alle

Denne delen gir en trinnvis beskrivelse av hvordan du programmatisk utfører alle endringer fra arbeidsområdet til Git.

Hvis du vil ha hele skriptet, kan du se Utføre alle endringer i Git.

  1. Logg på Git, og få godkjenning.
  2. Koble til arbeidsområde.
  3. Kall utføringen til GIT REST-API-en.
  4. Få operasjons-ID for lang kjøring for å finne statusen for operasjonen.

Selektiv forpliktelse

Denne delen beskriver trinnene som er involvert i å utføre bare spesifikke endringer fra arbeidsområdet til Git.

Hvis du vil ha det fullstendige skriptet, kan du se Utføre valg av endringer i Git.

  1. Logg på Git, og få godkjenning.
  2. Koble til arbeidsområde.
  3. Kall API-en Hent status for å se hvilke elementer-arbeidsområdet som ble endret.
  4. Velg de bestemte elementene som skal utføres.
  5. Kall Utfør til Git-API-en for å utføre de valgte endringene fra arbeidsområdet til den tilkoblede eksterne grenen.

Overvåk fremdriften for operasjoner som kjører lenge

Hvis du vil se hele skriptet, kan du se Avspørr en langvarig operasjon.

  1. Hent operationId fra Update From Git eller Commit to Git-skriptet .
  2. Kall API-en Hent LRO-status med angitte intervaller (i sekunder), og skriv ut statusen.

Få eller opprett legitimasjonstilkobling for Git-leverandør

Hvis du vil koble til et Git-repositorium eller oppdatere Git-legitimasjonen, må du oppgi en connectionId. connectionId kan komme fra enten en ny tilkobling som du oppretter, eller en eksisterende tilkobling.

Opprett en ny tilkobling som lagrer Git-legitimasjonen din

Følgende kodesnutt viser et eksempel på forespørselstekst for å opprette en tilkobling som lagrer Azure DevOps-legitimasjonen. Det fullstendige eksemplet finner du i repositoriet Stoffprøver.

# 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)

Eksempel på forespørsel

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>”
    }
  }
}

Eksempel på svar:

{
  "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
  }
}

Få en liste over eksisterende tilkoblinger

Bruk API-en for List-tilkoblinger for å få en liste over eksisterende tilkoblinger som du har tillatelser til, og deres egenskaper.

Eksempelforespørsel

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

Eksempelsvar

{
 "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
   }
  }
 ]
}

Kopier ID-en for tilkoblingen du vil bruke, og bruk den i API-en Git – Koble til eller Git – Oppdater Min Git-legitimasjon .

Hensyn og begrensninger

  • Git-integrering ved hjelp av API-er er underlagt de samme begrensningene som brukergrensesnittet for Git-integrering.
  • Oppdatering av en semantisk modell ved hjelp av API-en for forbedret oppdatering forårsaker en Git-diff etter hver oppdatering.

Relatert innhold

  • Last updated on