Condividi tramite

Automatizzare l'integrazione di Git usando le API

  • Articolo

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.

Prerequisiti

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, occorre 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:

Esempi

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.

  1. Accedere e ottenere il token di accesso: accedere a Fabric come utente (non un'entità servizio). Usare il comando Connect-AzAccount per effettuare l'accesso. Per ottenere un token di accesso, usare il comando Get-AzAccessToken.

    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
    $fabricToken = (Get-AzAccessToken -ResourceUrl $global:resourceUrl).Token

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

    
# 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 = @{
    gitProviderDetails =$azureDevOpsDetails
} | 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 commit su cui è stato eseguito il push nel ramo connesso.

Esegui commit di tutto

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. Chiamare il commit nell'API REST Git .
  4. Ottenere l'Id operazione a esecuzione prolungata per eseguire il polling dello 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 su cui eseguire per il commit.
  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 Update From Git o commit in Git .
  2. Chiamare l'API Get LRO Status a intervalli specificati (in secondi) e stampare lo stato.

Considerazioni e limitazioni

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

Contenuto correlato