Del via

Automatiser Git-integration ved hjælp af API'er

Microsoft Fabric Git-integrationsværktøjet gør det muligt for teams at arbejde sammen ved hjælp af kildekontrol for at opbygge en effektiv og genanvendelig udgivelsesproces for deres Fabric-indhold.

Med Microsoft Fabric REST API'er kan du automatisere Fabric-procedurer og -processer for at udføre opgaver hurtigere og med færre fejl. Denne effektivitet medfører omkostningsbesparelser og forbedret produktivitet.

I denne artikel beskrives det, hvordan du bruger REST API'er til Git-integration til at automatisere Git-integration i Microsoft Fabric.

Prerequisites

Hvis du vil arbejde med Fabric Git-API'er, skal du bruge:

Du kan bruge REST-API'erne uden PowerShell, men scripts i denne artikel bruger PowerShell. Hvis du vil køre scripts, skal du benytte følgende fremgangsmåde:

API-funktioner til Git-integration

REST API'er til Git-integration kan hjælpe dig med at opnå kontinuerlig integration og kontinuerlig levering (CI/CD) af dit indhold. Her er nogle eksempler på, hvad der kan gøres ved hjælp af API'erne:

Examples

Brug følgende PowerShell-scripts til at forstå, hvordan du udfører flere almindelige automatiseringsprocesser. Hvis du vil have vist eller kopiere teksten i et PowerShell-eksempel, skal du bruge linkene i dette afsnit. Du kan også se alle eksemplerne i GitHub-lageret med Fabric Git-integrationseksempler .

Opret forbindelse, og opdater

I dette afsnit beskrives de trin, der er involveret i at oprette forbindelse til og opdatere et arbejdsområde med Git.

Du kan se hele scriptet under Opret forbindelse og opdater fra Git. (Scriptkompatibiliteten er PowerShell 5.1)

  1. Forbind til Azure-konto og få adgangstoken - Log ind på Fabric som bruger eller service principal. Brug kommandoen Connect-AzAccount til at oprette forbindelse. Hvis du vil have et adgangstoken, skal du bruge kommandoen Get-AzAccessToken og konvertere sikkerhedsstrengtokenet til almindelig tekst

    Din kode bør se nogenlunde sådan ud:

     $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. Kald Connect-API'en for at oprette forbindelse mellem arbejdsområdet og et Git-lager og en Git-forgrening. (du skal muligvis oprette en forbindelse først)

    For information om, hvordan du får forbindelsesdetaljer (ID, Navn), se Get or create Git provider credentials connection.

    $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. Kald API'en Initialiser forbindelse for at initialisere forbindelsen mellem arbejdsområdet og Git-lageret/-forgreningen.

    # 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. Baseret på svaret fra API'en til initialisering af forbindelse skal du enten kalde API'en Opdater fra Git for at fuldføre opdateringen eller foretage dig noget, hvis der ikke kræves nogen handling.

    Følgende script opdaterer og overvåger status:

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

Opdatering fra Git

I dette afsnit beskriver vi de trin, der er involveret i opdatering af et arbejdsområde med ændringerne fra Git. I dette script opdaterer vi elementerne i arbejdsområdet med ændringer fra Git, men vi lader Git-lageret være uændret.

Du kan se hele scriptet under Opdater arbejdsområde fra Git.

  1. Log på Git, og hent godkendelse.
  2. Kald API'en Hent status for at oprette opdateringen fra Git-anmodningsteksten.
  3. Kald Api'en Opdater fra Git for at opdatere arbejdsområdet med bekræftelser, der er pushet til den forbundne forgrening.

Commit alle

Dette afsnit indeholder en trinvis beskrivelse af, hvordan du programmatisk kan bekræfte alle ændringer fra arbejdsområdet til Git.

Du kan se hele scriptet under Bekræft alle ændringer i Git.

  1. Log på Git, og hent godkendelse.
  2. Opret forbindelse til arbejdsområdet.
  3. Kald API'en Commit to Git REST.
  4. Hent Long Running OperationId for at forespørge om status for handlingen.

Selektiv commit

I dette afsnit beskrives de trin, der er involveret i kun at foretage bestemte ændringer fra arbejdsområdet til Git.

Du kan se hele scriptet under Bekræft valg af ændringer til Git.

  1. Log på Git, og hent godkendelse.
  2. Opret forbindelse til arbejdsområdet.
  3. Kald API'en Hent status for at se, hvilke elementer der er blevet ændret.
  4. Vælg de specifikke elementer, der skal bekræftes.
  5. Kald API'en Bekræft til Git for at bekræfte de valgte ændringer fra arbejdsområdet til den forbundne eksterne forgrening.

Overvåg status for langvarige handlinger

Du kan se hele scriptet under Poller en handling, der kører i lang tid.

  1. Hent operationId fra Update From Git eller scriptet Commit to Git .
  2. Kald API'en Hent LRO-status med angivne intervaller (i sekunder), og udskriv status.

Hent eller opret forbindelse til Legitimationsoplysninger for Git-udbyder

Hvis du vil oprette forbindelse til et Git-lager eller opdatere dine Git-legitimationsoplysninger, skal du angive et connectionId. connectionId kan komme fra enten en ny forbindelse, som du opretter, eller en eksisterende forbindelse.

Opret en ny forbindelse, der gemmer dine Git-oplysninger

Følgende kodeuddrag viser et eksempel på en anmodningskrop til at oprette en forbindelse, der gemmer dine Azure DevOps-oplysninger. Det fulde eksempel kan findes i Fabric samples-repoet.

# 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å anmodning

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

Hent en liste over eksisterende forbindelser

Brug API'en Listeforbindelser til at få vist en liste over eksisterende forbindelser, som du har tilladelser til, og deres egenskaber.

Eksempelanmodning

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

Kopiér id'et for den ønskede forbindelse, og brug det i API'en Git – Opret forbindelse eller Git – Opdater Mine Git-legitimationsoplysninger .

Overvejelser og begrænsninger

  • Git-integration ved hjælp af API'er er underlagt de samme begrænsninger som Git-integrationsbrugergrænsefladen.
  • Opdatering af en semantisk model ved hjælp af API'en for udvidet opdatering medfører en Git-diff efter hver opdatering.

Relateret indhold

  • Last updated on