Partilhar via

Automatize a integração do Git usando APIs

A ferramenta de integração do Microsoft Fabric Git permite que as equipes trabalhem juntas usando o controle do código-fonte para criar um processo de liberação eficiente e reutilizável para seu conteúdo do Fabric.

Com as APIs REST do Microsoft Fabric, você pode automatizar procedimentos e processos do Fabric para concluir tarefas mais rapidamente e com menos erros. Esta eficiência conduz a poupanças de custos e a uma maior produtividade.

Este artigo descreve como usar as APIs REST de integração do Git para automatizar a integração do Git no Microsoft Fabric.

Prerequisites

Para trabalhar com APIs do Fabric Git, você precisa:

Você pode usar as APIs REST sem o PowerShell, mas os scripts neste artigo usam o PowerShell. Para executar os scripts, execute as seguintes etapas:

Funções da API de integração do Git

As APIs REST de integração do Git podem ajudá-lo a alcançar a integração contínua e a entrega contínua (CI/CD) do seu conteúdo. Aqui estão alguns exemplos do que pode ser feito usando as APIs:

Examples

Use os seguintes scripts do PowerShell para entender como executar vários processos de automação comuns. Para exibir ou copiar o texto em um exemplo do PowerShell, use os links nesta seção. Você também pode ver todos os exemplos no repositório GitHub de exemplos de integração do Fabric Git.

Ligar e atualizar

Esta seção descreve as etapas envolvidas na conexão e atualização de um espaço de trabalho com o Git.

Para obter o script completo, consulte Conectar e atualizar do Git. (A compatibilidade de script é o PowerShell 5.1)

  1. Conectar-se à conta do Azure e obter token de acesso - Entre no Fabric como um utilizador ou uma entidade de serviço. Use o comando Connect-AzAccount para se conectar. Para obter um token de acesso, use o comando Get-AzAccessToken e converta o token de cadeia de caracteres segura em texto sem formatação

    Seu código deve ter esta aparência:

     $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. Chame a API Connect para conectar o espaço de trabalho a um repositório Git e ramificação. (talvez seja necessário criar uma conexão primeiro)

    Para obter informações sobre como obter os detalhes da conexão (ID, nome), consulte Obter ou criar conexão de credenciais do provedor 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. Chame a API Initialize Connection para inicializar a conexão entre o espaço de trabalho e o repositório/ramificação 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. Com base na resposta da API Initialize Connection, chame a Update From Git API para concluir a atualização ou não faça nada se nenhuma ação for necessária.

    O script a seguir atualiza e monitora o progresso:

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

Atualização do Git

Nesta seção, descrevemos as etapas envolvidas na atualização de um espaço de trabalho com as alterações do Git. Neste script, atualizamos os itens do espaço de trabalho com alterações do Git, mas deixamos o repositório Git inalterado.

Para obter o script completo, consulte Atualizar espaço de trabalho do Git.

  1. Faça login no Git e obtenha autenticação.
  2. Chame a API Get Status para criar a atualização a partir do corpo da solicitação do Git.
  3. Chame a atualização da API do Git para atualizar o espaço de trabalho com confirmações enviadas por push para a ramificação conectada.

Confirmar tudo

Esta seção fornece uma descrição passo a passo de como confirmar programaticamente todas as alterações do espaço de trabalho para o Git.

Para obter o script completo, consulte Confirmar todas as alterações no Git.

  1. Faça login no Git e obtenha autenticação.
  2. Conecte-se ao espaço de trabalho.
  3. Chame a API REST Commit to Git.
  4. Obtenha o ID de operação de longa duração para monitorizar o estado da operação.

Confirmação seletiva

Esta seção descreve as etapas envolvidas em confirmar apenas alterações específicas da área de trabalho para o Git.

Para o script completo, consulte Cometer alterações selecionadas no Git.

  1. Faça login no Git e obtenha autenticação.
  2. Conecte-se ao espaço de trabalho.
  3. Ligue a API de obtenção de estado para ver quais itens do espaço de trabalho foram alterados.
  4. Selecione os itens específicos para confirmar.
  5. Chame a API Commit to Git para confirmar as alterações selecionadas do espaço de trabalho para a ramificação remota conectada.

Monitorar o progresso de operações de longa duração

Para obter o script completo, consulte Sondar uma operação de longa duração.

  1. Recupere o operationId do script Atualizar do Git ou Confirmar para o Git.
  2. Chame a API Get LRO Status em intervalos especificados (em segundos) e imprima o status.

Obter ou criar conexão de credenciais do provedor Git

Para se conectar a um repositório Git ou atualizar suas credenciais Git, você precisa fornecer um connectionId. O connectionId pode vir de uma nova conexão criada por você ou de uma conexão existente.

Crie uma nova conexão que armazene suas credenciais do Git

O trecho de código a seguir mostra um corpo de solicitação de exemplo para criar uma conexão que armazena suas credenciais do Azure DevOps. O exemplo completo pode ser encontrado no repositório de amostras de tecido.

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

Pedido de amostra

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

Exemplo de resposta:

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

Obter uma lista de conexões existentes

Use a API Listar conexões para obter uma lista de conexões existentes para as quais você tem permissões e suas propriedades.

Pedido de amostra

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

Resposta da amostra

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

Copie o ID da conexão desejada e use-o na API Git - Connect ou Git - Update My Git Credentials .

Considerações e limitações

  • A integração do Git usando APIs está sujeita às mesmas limitações da interface do usuário de integração do Git.
  • A atualização de um modelo semântico usando a API de atualização aprimorada causa uma diferença do Git após cada atualização.

Conteúdo relacionado

  • Last updated on