Condividi tramite

Automatizzare l'integrazione di Git usando le API

Lo strumento di integrazione Git di Microsoft Fabric consente ai team di collaborare usando il controllo del codice sorgente per creare un processo di rilascio efficiente e riutilizzabile per il contenuto di Fabric.

Con le API REST di Microsoft Fabric, è possibile automatizzare le procedure e i processi di Fabric per completare le attività più velocemente e con un minor numero di errori. Questa efficienza comporta risparmi sui costi e una maggiore produttività.

Questo articolo descrive come usare le API REST di integrazione Git per automatizzare l'integrazione Git in Microsoft Fabric.

Prerequisites

Per lavorare con le API Git di Fabric, è necessario disporre di:

È possibile usare le API REST senza PowerShell, ma gli script in questo articolo usano PowerShell. Per eseguire gli script, seguire questa procedura:

Funzioni dell'API di integrazione Git

Le API REST di integrazione Git consentono di ottenere integrazione continua e recapito continuo (CI/CD) del contenuto. Ecco alcuni esempi di operazioni che possono essere eseguite usando le API:

Examples

Usare gli script di PowerShell seguenti per comprendere come eseguire diversi processi di automazione comuni. Per visualizzare o copiare il testo in un esempio di PowerShell, usare i collegamenti in questa sezione. È anche possibile vedere tutti gli esempi nel repository GitHub degli esempi di integrazione Git di Fabric.

Connettersi e aggiornare

Questa sezione descrive i passaggi necessari per la connessione e l'aggiornamento di un'area di lavoro con Git.

Per lo script completo, vedere Connettersi e aggiornare da Git. (La compatibilità degli script è PowerShell 5.1)

  1. Connettersi all'account Azure e ottenere il token di accesso : accedere a Fabric come utente o entità servizio. Usare il comando Connect-AzAccount per connettersi. Per ottenere un token di accesso, usare il comando Get-AzAccessToken e convertire il token di stringa sicura in testo normale

    Il codice dovrebbe essere simile al seguente:

     $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. Chiamare l'API Connetti per connettere l'area di lavoro a un repository Git e a un ramo. (potrebbe essere necessario creare prima una connessione )

    Per informazioni su come ottenere i dettagli della connessione (ID, nome), vedere Ottenere o creare una connessione alle credenziali del provider Git.

    $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. Chiamare l'API Inizializza connessione per inizializzare la connessione tra l'area di lavoro e il repository/ramo Git.

    # 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. In base alla risposta dell'API Di inizializzazione connessione, chiamare l'API Update From Git per completare l'aggiornamento o non eseguire alcuna operazione se non è necessaria alcuna azione.

    Lo script seguente aggiorna e monitora lo stato di avanzamento:

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

Aggiornare da Git

In questa sezione, vengono descritti i passaggi necessari per aggiornare un'area di lavoro con le modifiche apportate da Git. In questo script, gli elementi dell'area di lavoro vengono aggiornati con le modifiche da Git, ma il repository Git rimane invariato.

Per lo script completo, vedere Aggiornare l'area di lavoro da Git.

  1. Accedere a Git e ottenere l'autenticazione.
  2. Chiamare l'API Ottieni stato per compilare l'aggiornamento dal corpo della richiesta Git.
  3. Chiamare l'API Aggiorna da Git per aggiornare l'area di lavoro con i commit inviati al ramo connesso.

Esegui il commit di tutte le modifiche

Questa sezione fornisce una descrizione dettagliata di come eseguire il commit a livello di codice di tutte le modifiche dall'area di lavoro a Git.

Per lo script completo, vedere Eseguire il commit di tutte le modifiche in Git.

  1. Accedere a Git e ottenere l'autenticazione.
  2. Connettersi all'area di lavoro.
  3. Chiama l'API REST Commit to Git.
  4. Ottenere l'OperationId a lunga esecuzione per monitorare lo stato dell'operazione.

Commit selettivo

Questa sezione descrive i passaggi necessari per eseguire il commit solo di modifiche specifiche dall'area di lavoro a Git.

Per lo script completo, vedere Eseguire il commit di modifiche selezionate in Git.

  1. Accedere a Git e ottenere l'autenticazione.
  2. Connettersi all'area di lavoro.
  3. Chiamare l'API Ottieni stato per vedere quali elementi delle aree di lavoro sono stati modificati.
  4. Selezionare gli elementi specifici da confermare.
  5. Chiamare l'API Commit in Git per eseguire il commit delle modifiche selezionate dall'area di lavoro al ramo remoto connesso.

Monitorare lo stato di avanzamento delle operazioni a esecuzione prolungata

Per lo script completo, vedere Eseguire il polling di un'operazione a esecuzione prolungata.

  1. Recuperare l'operationId dallo script Aggiorna da Git o dallo script Commit su Git.
  2. Chiamare l'API Get LRO Status a intervalli specificati (in secondi) e stampare lo stato.

Ottenere o creare una connessione alle credenziali del provider Git

Per connettersi a un repository Git o aggiornare le credenziali Git , è necessario fornire un connectionId. ConnectionId può provenire da una nuova connessione creata o da una connessione esistente.

Creare una nuova connessione che archivia le credenziali Git

Il frammento di codice seguente mostra un corpo di richiesta di esempio per creare una connessione che archivia le credenziali di Azure DevOps. L'esempio completo è disponibile nel repository degli esempi di Fabric.

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

Esempio di richiesta

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

Risposta di esempio:

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

Ottenere un elenco di connessioni esistenti

Usare l'API Elenca connessioni per ottenere un elenco di connessioni esistenti per cui si dispone delle autorizzazioni e delle relative proprietà.

Esempio di richiesta

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

Risposta di esempio

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

Copiare l'ID della connessione desiderata e usarlo nell'API Git - Connect o Git - Update My Git Credentials (Aggiornare le credenziali Git personali ).

Considerazioni e limitazioni

  • L'integrazione Git con le API è soggetta alle stesse limitazioni dell'interfaccia utente dell'integrazione Git.
  • L'aggiornamento di un modello semantico tramite l'API Aggiornamento avanzato causa una differenza di Git dopo ogni aggiornamento.

Contenuti correlati

  • Last updated on