Freigeben über

Automatisieren der Git-Integration mithilfe von APIs

Mit dem Microsoft Fabric-Tool zur Git-Integration können Teams zusammenarbeiten, um mit Hilfe von Quellcodeverwaltung einen effizienten und wiederverwendbaren Releaseprozess für ihre Fabric-Inhalte zu erstellen.

Mit der Microsoft Fabric-REST-API können Sie Fabric-Vorgehensweisen und -Prozesse automatisieren, um Aufgaben schneller und mit weniger Fehlern zu erledigen. Dieses effiziente Verfahren führt zu Kosteneinsparungen und Produktivitätssteigerungen.

In diesem Artikel wird beschrieben, wie Sie die die Git-Integration in Microsoft Fabric mit Hilfe der Git-Integrations-REST-API automatisieren.

Prerequisites

Um mit Fabric-Git-APIs zu arbeiten, benötigen Sie:

Sie können die REST-APIs ohne PowerShell verwenden, aber die Skripts in diesem Artikel verwenden PowerShell. Führen Sie zum Ausführen der Skripts die folgenden Schritte aus:

API-Funktionen zur Git-Integration

Die GIT-Integrations-REST-API können Ihnen dabei helfen, Ihre Inhalte kontinuierlich zu integrieren und bereitzustellen (Continuous Integration und Continuous Delivery; CI/CD). Im Folgenden finden Sie einige Beispiele dafür, was mithilfe der API möglich ist:

Examples

Verwenden Sie die folgenden PowerShell-Skripts, um herauszufinden, wie mehrere geläufige Automatisierungsprozesse ausgeführt werden. Verwenden Sie die Links in diesem Abschnitt, um den Text in einem PowerShell-Beispiel anzuzeigen oder zu kopieren. Sie können alle Beispiele auch im GitHub-Repositorys der Fabric Git-Integrationsbeispiele sehen.

Verbinden und aktualisieren

Dieser Abschnitt erklärt, welche Schritte erforderlich sind, um einen Arbeitsbereich mit Git zu verbinden und zu aktualisieren.

Sie finden das vollständige Skript unter Mit Git verbinden und von dort aktualisieren. (Die Skriptkompatibilität ist PowerShell 5.1)

  1. Stellen Sie eine Verbindung mit Azure-Konto her, und erhalten Sie Zugriffstoken – Melden Sie sich als Benutzer oder Dienstprinzipal bei Fabric an. Verwenden Sie den Befehl "Connect-AzAccount ", um eine Verbindung herzustellen. Verwenden Sie zum Abrufen eines Zugriffstokens den Befehl "Get-AzAccessToken", und konvertieren Sie das sicheren Zeichenfolgen-Token in Klartext.

    Ihr Code sollte in etwa wie folgt aussehen:

     $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. Rufen Sie die Connect-API auf, um den Arbeitsbereich mit einem Git-Repository und einer Verzweigung zu verbinden. (Möglicherweise müssen Sie zuerst eine Verbindung erstellen )

    Informationen zum Abrufen der Verbindungsdetails (ID, Name) finden Sie unter Abrufen oder Erstellen einer Git-Anbieteranmeldeinformationenverbindung.

    $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. Rufen Sie die Initialize-Connection-API auf, um die Verbindung zwischen dem Arbeitsbereich und der Git-Repository-Verzweigung zu initialisieren.

    # 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. Rufen Sie je nach Antwort der Initialize Connection-API die Update from Git-API auf, um die Synchronisierung abzuschließen, oder führen Sie keine Aktion aus, wenn keine erforderlich ist.

    Das folgende Skript aktualisiert und überwacht den Fortschritt:

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

Aus Git aktualisieren

In diesem Abschnitt beschreiben wir die Schritte, die zur Aktualisierung eines Arbeitsbereichs mit den Änderungen aus Git erforderlich sind. In diesem Skript aktualisieren wir die Arbeitsbereichselemente mit Änderungen aus Git, lassen das Git-Repository dabei aber unverändert.

Das vollständige Skript finden Sie unter Aktualisieren des Arbeitsbereichs aus Git.

  1. Melden Sie sich bei Git an und rufen Sie die Authentifizierung ab.
  2. Rufen Sie die Get-Status-API auf, um das Update aus dem Git-Anforderungstext zu erstellen.
  3. Rufen Sie die Update-From-Git-API auf, um den Arbeitsbereich mit Commits zu aktualisieren, die an die verbundene Verzweigung gepushed werden.

Alle committen

Dieser Abschnitt enthält eine schrittweise Beschreibung, wie sämtliche Änderungen vom Arbeitsbereich programmgesteuert auf Git committet werden.

Das vollständige Skript finden Sie in alle Änderungen in Git übernehmen.

  1. Melden Sie sich bei Git an und rufen Sie die Authentifizierung ab.
  2. Herstellen einer Verbindung mit dem Arbeitsbereich
  3. Rufen Sie die Commit to Git-REST-API auf.
  4. Nutzen Sie die Long Running OperationId, um den Status des Vorgangs abzurufen.

Selektive Commits

In diesem Abschnitt werden die Schritte erläutert, mit denen Sie nur bestimmte Änderungen vom Arbeitsbereich in Git übertragen können.

Für das vollständige Skript siehe Ausgewählte Änderungen in Git festschreiben.

  1. Melden Sie sich bei Git an und rufen Sie die Authentifizierung ab.
  2. Herstellen einer Verbindung mit dem Arbeitsbereich
  3. Rufen Sie die Get-Status-API auf, um zu sehen, welche Elemente im Arbeitsbereich geändert wurden.
  4. Wählen Sie nur jene Elemente aus, die Sie committen möchten.
  5. Rufen Sie die Commit to Git-API auf, um die ausgewählten Änderungen vom Arbeitsbereich in den verbundenen Remote-Branch zu übertragen.

Überwachen Sie den Verlauf zeitintensiver Vorgänge

Ein vollständiges Skript finden Sie unter Abruf einer lang laufenden Operation.

  1. Rufen Sie die operationId aus dem einem der Skripts Update from Git oder Commit to Git ab.
  2. Rufen Sie die Get LRO Status-API in festgelegten Intervallen auf, und drucken Sie den Status.

Abrufen oder Erstellen einer Verbindung mit Git-Anbieteranmeldeinformationen

Um eine Verbindung mit einem Git-Repository herzustellen oder Ihre Git-Anmeldeinformationen zu aktualisieren , müssen Sie eine connectionId angeben. Die connectionId kann entweder aus einer neuen Verbindung stammen, die Sie erstellen, oder einer vorhandenen Verbindung.

Erstellen einer neuen Verbindung, die Ihre Git-Anmeldeinformationen speichert

Der folgende Codeausschnitt zeigt einen Beispielanforderungstext zum Erstellen einer Verbindung, die Ihre Azure DevOps-Anmeldeinformationen speichert. Das vollständige Beispiel finden Sie im Fabric-Beispiel-Repository.

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

Beispielanforderung

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

Beispielantwort:

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

Abrufen einer Liste vorhandener Verbindungen

Verwenden Sie die Listenverbindungen-API , um eine Liste vorhandener Verbindungen abzurufen, für die Sie über Berechtigungen verfügen, und deren Eigenschaften.

Musteranforderung

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

Beispielantwort

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

Kopieren Sie die ID der gewünschten Verbindung, und verwenden Sie sie in der Git -Connect - oder Git - Update My Git Credentials API.

Überlegungen und Einschränkungen

  • Die Git-Integration mit Hilfe von API unterliegt den gleichen Einschränkungen wie die Git-Integrations-Benutzeroberfläche.
  • Das Aktualisieren eines semantischen Modells mit der erweiterten Aktualisierungs-API führt nach jeder Aktualisierung zu einem Git-diff.

Verwandte Inhalte

  • Last updated on