Compartilhar via

Automatizar a integração do Git usando APIs

A ferramenta de integração do Git do Microsoft Fabric permite que as equipes trabalhem juntas usando o controle do código-fonte para criar um processo de lançamento 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 com mais rapidez e menos erros. Essa eficiência proporciona economia de custos e 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.

Pré-requisitos

Para trabalhar com APIs Git do Fabric, são necessários:

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 auxiliar a alcançar a CI/CD (integração contínua e a entrega contínua) do conteúdo. Aqui estão alguns exemplos do que pode ser feito usando as APIs:

Exemplos

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

Conectar e atualizar

Nesta seção, descrevemos 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. Conecte-se à conta do Azure e obtenha um token de acesso – entre no Fabric como usuário (ou, se estiver usando o GitHub, um usuário 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 seguro em texto sem formatação

    Seu código deve ter a seguinte 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 workspace a um repositório e ramificação do Git. (talvez seja necessário criar uma conexão( primeiro)

    $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 = @{
    gitProviderDetails = $azureDevOpsDetails
} | 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/branch do 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 API Atualizar do Git 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"))
}

Atualizar a partir 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 as alterações do Git, mas deixamos o repositório Git inalterado.

Para verificar o script completo, confira Atualizar espaço de trabalho do Git.

  1. Entre no Git e obtenha autenticação.
  2. Chame a API Get Status para criar a atualização do corpo da solicitação do Git.
  3. Chame a API Update From Git para atualizar o espaço de trabalho com commits enviados 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, confira Confirmar todas as alterações no Git.

  1. Entre no Git e obtenha autenticação.
  2. Conecte-se ao espaço de trabalho.
  3. Chame a API REST Confirmar para Git.
  4. Obtenha a OperationId de execução prolongada para pesquisar o status da operação.

Confirmação seletiva

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

Para obter o script completo, confira Confirmar alterações selecionadas no Git.

  1. Entre no Git e obtenha autenticação.
  2. Conecte-se ao espaço de trabalho.
  3. Chame a API Obter status para ver quais itens do espaço de trabalho foram alterados.
  4. Selecione os itens específicos a serem confirmados.
  5. Chame a API Confirmar para Git para confirmar as alterações selecionadas do workspace para a ramificação remota conectada.

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

Para verificar o script completo, confira Apurar uma operação de execução prolongada.

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

Obter ou criar a conexão de credenciais do provedor Git

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

Criar uma nova conexão que armazene suas credenciais do GitHub

Use o PAT (Token de Acesso Pessoal) para criar uma conexão do GitHub.

Se você fornecer o nome de um repositório específico, sua conexão estará no escopo desse repositório. Se você não fornecer o nome de nenhum repositório, terá acesso a todos os repositórios para os quais tem permissão.

Para criar uma conexão que armazene suas credenciais do GitHub, chame a API criar conexão com o corpo da solicitação a seguir. A seção de parâmetros é opcional e só será necessária se você quiser que sua conexão tenha escopo para um repositório específico.

Solicitação de exemplo

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

{
 "connectivityType": "ShareableCloud",
 "displayName": "MyGitHubPAT",
 "connectionDetails": {
  "type": "GitHubSourceControl",
  "creationMethod": "GitHubSourceControl.Contents",
  "parameters": [
   {
    "dataType": "Text",
    "name": "url",
    "value": "https://github.com/OrganizationName/RepositoryName"
   }
  ]
 },
 "credentialDetails": {
  "credentials": {
   "credentialType": "Key",
   "key": "*********"  //Enter your GitHub Personal Access Token
  }
 }
}

Resposta de exemplo:

{
  "id": "3aba8f7f-d1ba-42b1-bb41-980029d5a1c1",
   "connectionDetails": {
       "path": "https://github.com/OrganizationName/RepositoryName",
       "type": "GitHubSourceControl"
   },
   "connectivityType": "ShareableCloud",
   "credentialDetails": {
       "connectionEncryption": "NotEncrypted",
       "credentialType": "Key",
       "singleSignOnType": "None",
       "skipTestConnection": false
   },
   "displayName": "MyGitHubPAT",
   "gatewayId": null,
   "privacyLevel": "Organizational"
}

Copie a ID e use-a na API Git – Connect ou Git – Atualizar Minhas Credenciais do Git .

Obter uma lista de conexões existentes

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

Solicitação de exemplo

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

Resposta de exemplo

{
 "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 a ID da conexão desejada e use-a na API Git – Connect ou Git – Atualizar Minhas Credenciais do Git .

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 entidade de serviço só tem suporte para o GitHub.
  • Atualizar um modelo semântico usando a API de atualização aprimorada resulta em uma diferença no Git após cada atualização.

Conteúdo relacionado