Delen via

Git-integratie automatiseren met behulp van API's

Met het Microsoft Fabric Git-integratiehulpprogramma kunnen teams samenwerken met behulp van broncodebeheer om een efficiënt en herbruikbaar releaseproces voor hun Fabric-inhoud te bouwen.

Met REST API's van Microsoft Fabric kunt u Fabric-procedures en -processen automatiseren om taken sneller en met minder fouten te voltooien. Deze efficiëntie leidt tot kostenbesparingen en verbeterde productiviteit.

In dit artikel wordt beschreven hoe u de REST API's voor Git-integratie gebruikt om Git-integratie in Microsoft Fabric te automatiseren.

Prerequisites

Als u wilt werken met Git-API's voor Fabric, hebt u het volgende nodig:

U kunt de REST API's zonder PowerShell gebruiken, maar de scripts in dit artikel gebruiken PowerShell. Voer de volgende stappen uit om de scripts uit te voeren:

Api-functies voor Git-integratie

De REST API's voor Git-integratie kunnen u helpen bij het bereiken van de continue integratie en continue levering (CI/CD) van uw inhoud. Hier volgen enkele voorbeelden van wat u kunt doen met behulp van de API's:

Examples

Gebruik de volgende PowerShell-scripts om te begrijpen hoe u verschillende algemene automatiseringsprocessen uitvoert. Als u de tekst in een PowerShell-voorbeeld wilt weergeven of kopiëren, gebruikt u de koppelingen in deze sectie. U kunt ook alle voorbeelden bekijken in de Fabric Git integratie voorbeelden GitHub-repository.

Verbinding maken en bijwerken

In deze sectie worden de stappen beschreven die nodig zijn voor het verbinden en bijwerken van een werkruimte met Git.

Zie Verbinding maken en bijwerken vanuit Git voor het volledige script. (De scriptcompatibiliteit is PowerShell 5.1)

  1. Verbinding maken met een Azure-account en toegangstoken ophalen : meld u als gebruiker of service-principal aan bij Fabric. Gebruik de opdracht Connect-AzAccount om verbinding te maken. Als u een toegangstoken wilt ophalen, gebruikt u de opdracht Get-AzAccessToken en converteert u het beveiligde tekenreekstoken naar tekst zonder opmaak

    Uw code moet er ongeveer als volgt uitzien:

     $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. Roep de Connect-API aan om de werkruimte te verbinden met een Git-opslagplaats en -vertakking. (Mogelijk moet u eerst een verbinding maken )

    Raadpleeg voor informatie over het verkrijgen van de verbindingsdetails (ID, Naam) de instructies in Verbinding maken of verkrijgen met referenties van de Git-provider.

    $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. Roep de Initialize Connection-API aan om de verbinding tussen de werkruimte en de Git-opslagplaats/vertakking te initialiseren.

    # 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. Roep op basis van het antwoord van de Initialize Connection API de Update From Git-API aan om de update te voltooien of doe niets als er geen actie is vereist.

    Het volgende script wordt bijgewerkt en bewaakt de voortgang:

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

Bijwerken vanuit Git

In deze sectie beschrijven we de stappen voor het bijwerken van een werkruimte met de wijzigingen van Git. In dit script werken we de werkruimte-items bij met wijzigingen van Git, maar laten we de Git-opslagplaats ongewijzigd.

Zie Werkruimte bijwerken vanuit Git voor het volledige script.

  1. Meld u aan bij Git en ontvang verificatie.
  2. Roep de Get Status-API aan om de update te bouwen vanuit de hoofdtekst van de Git-aanvraag.
  3. Roep de Update From Git-API aan om de werkruimte bij te werken met commits die naar de verbonden branch zijn gepusht.

Alles doorvoeren

Deze sectie bevat een stapsgewijze beschrijving van het programmatisch doorvoeren van alle wijzigingen van de werkruimte naar Git.

Zie Alle wijzigingen doorvoeren in Git voor het volledige script.

  1. Meld u aan bij Git en ontvang verificatie.
  2. Verbinding maken met werkruimte.
  3. Roep de Commit to Git REST API aan.
  4. Verkrijg de ID van de langdurige operatie om de voortgang van de operatie te volgen.

Selectief doorvoeren

In deze sectie worden de stappen beschreven die nodig zijn voor het doorvoeren van alleen specifieke wijzigingen van de werkruimte naar Git.

Zie Wijzigingen selecteren en doorvoeren naar Git voor het volledige script.

  1. Meld u aan bij Git en ontvang verificatie.
  2. Verbinding maken met werkruimte.
  3. Roep de GET-status-API aan om te zien welke items werkruimte is gewijzigd.
  4. Selecteer de specifieke items die u wilt doorvoeren.
  5. Roep de Doorvoer aan de Git-API aan om de geselecteerde wijzigingen van de werkruimte door te voeren naar de verbonden externe vertakking.

De voortgang van langdurige bewerkingen volgen

Voor het volledige script, zie Polling van een langdurige bewerking.

  1. Haal de operationId op uit de Update From Git of het Commit to Git-script.
  2. Roep de GET LRO-status-API aan met opgegeven intervallen (in seconden) en druk de status af.

Verbindingsreferentie voor Git-provider verkrijgen of aanmaken

Als u verbinding wilt maken met een Git-opslagplaats of uw Git-referenties wilt bijwerken , moet u een connectionId opgeven. De connectionId kan afkomstig zijn van een nieuwe verbinding die u maakt of een bestaande verbinding.

Een nieuwe verbinding maken waarin uw Git-referenties worden opgeslagen

In het volgende codefragment ziet u een voorbeeld van een aanvraagbody voor het maken van een verbinding waarin uw Azure DevOps-referenties worden opgeslagen. Het volledige voorbeeld vindt u in de Fabric-voorbeeldenopslagplaats.

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

Voorbeeldaanvraag

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

Voorbeeldantwoord:

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

Een lijst met bestaande verbindingen ophalen

Gebruik de API lijstverbindingen om een lijst op te halen met bestaande verbindingen waarvoor u machtigingen hebt en de bijbehorende eigenschappen.

Voorbeeldaanvraag

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

Voorbeeldantwoord

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

Kopieer de id van de gewenste verbinding en gebruik deze in git - Verbinding maken of Git - Mijn Git-referenties-API bijwerken .

Overwegingen en beperkingen

  • Git-integratie met behulp van API's is onderhevig aan dezelfde beperkingen als de gebruikersinterface van Git-integratie.
  • Als u een semantisch model vernieuwt met behulp van de uitgebreide vernieuwings-API, wordt na elke vernieuwing een Git-diff veroorzaakt.

Verwante inhoud

  • Last updated on