Compartir a través de

Automatización de la integración de Git mediante API

La herramienta de integración de Git de Microsoft Fabric permite a los equipos trabajar juntos utilizando el control de código fuente para crear un proceso de versión eficaz y reutilizable para tu contenido de Fabric.

Con las API de REST de Microsoft Fabric, puedes automatizar los procedimientos y procesos de Fabric para completar tareas más rápido y con menos errores. Esta eficiencia lleva a un ahorro de costos y mejora de la productividad.

En este artículo se describe cómo usar las API de REST de integración de Git para automatizar la integración de Git en Microsoft Fabric.

Prerequisites

Para trabajar con las API de Git de Fabric, necesita lo siguiente:

Puede usar las API rest sin PowerShell, pero los scripts de este artículo usan PowerShell. Para ejecutar los scripts, siga estos pasos:

Funciones de API de integración de Git

Las API de REST de integración de Git pueden ayudarte a lograr la integración continua y la entrega continua (CI/CD) del contenido. Estos son algunos ejemplos de lo que se puede hacer mediante las API:

Examples

Usa los siguientes scripts de PowerShell para comprender cómo realizar varios procesos de automatización habituales. Para ver o copiar el texto en un ejemplo de PowerShell, use los vínculos de esta sección. También puedes ver todos los ejemplos en el repositorio de GitHub de ejemplos de integración de Git de Fabric.

Conexión y actualización

En esta sección se describen los pasos necesarios para conectar y actualizar un área de trabajo con Git.

Para obtener el script completo, consulte Conectar y actualizar desde Git. (La compatibilidad del script es PowerShell 5.1)

  1. Conéctese a la cuenta de Azure y obtenga el token de acceso : inicie sesión en Fabric como usuario o entidad de servicio. Use el comando Connect-AzAccount para conectarse. Para obtener un token de acceso, use el comando Get-AzAccessToken y convierta el token de cadena segura en texto sin formato.

    El código debería tener este aspecto:

     $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. Llama a la API Conectar para conectar el área de trabajo a un repositorio y una rama de Git. (es posible que tenga que crear primero una conexión )

    Para obtener información sobre cómo obtener los detalles de conexión (identificador, nombre), consulte Obtención o creación de una conexión de credenciales del proveedor de 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. Llame a la API Inicializar conexión para inicializar la conexión entre el área de trabajo y el repositorio o la rama de 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. En función de la respuesta de la API Inicializar conexión, llame a la API Actualizar desde Git para completar la actualización o no haga nada si no se requiere ninguna acción.

    El siguiente script actualiza y supervisa el progreso:

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

Actualización desde Git

En esta sección, se describen los pasos necesarios para actualizar un área de trabajo con los cambios de Git. En este script, se actualizan los elementos del espacio de trabajo con cambios de Git, pero se deja sin cambios el propio repositorio de Git.

Para obtener el script completo, consulte Actualización del área de trabajo desde Git.

  1. Inicie sesión en Git y obtenga la autenticación.
  2. Llama a la API Get Status para crear la actualización a partir del cuerpo de la solicitud de Git.
  3. Llama a la API Actualizar desde Git para actualizar el área de trabajo con confirmaciones insertadas en la rama conectada.

Confirmar todo

En esta sección se proporciona una descripción paso a paso de cómo confirmar mediante programación todos los cambios del área de trabajo a Git.

Para obtener el script completo, consulte Confirmar todos los cambios en Git.

  1. Inicie sesión en Git y obtenga la autenticación.
  2. Conéctate al área de trabajo.
  3. Llame a la API de REST Confirmar en Git.
  4. Obtén el OperationId de larga duración para sondear el estado de la operación.

Compromiso selectivo

En esta sección se describen los pasos necesarios para confirmar solo cambios específicos del área de trabajo a Git.

Para obtener el script completo, consulte Confirmar cambios selectivos en Git.

  1. Inicie sesión en Git y obtenga la autenticación.
  2. Conéctate al área de trabajo.
  3. Llama a la API Obtener estado para ver qué áreas de trabajo se cambiaron.
  4. Selecciona los elementos concretos que deseas confirmar.
  5. Llama a la API Confirmar en Git para confirmar los cambios seleccionados del área de trabajo en la rama remota conectada.

Supervisión del progreso de las operaciones de larga duración

Para obtener el script completo, consulte Sondeo de una operación de larga duración.

  1. Recupere el operationId de los scripts Actualizar desde Git o Confirmar en Git.
  2. Llame a la API Obtener estado de LRO a intervalos especificados (en segundos) e imprima el estado.

Obtención o creación de una conexión de credenciales del proveedor de Git

Para conectarse a un repositorio de Git o actualizar las credenciales de Git , debe proporcionar un connectionId. ConnectionId puede provenir de una nueva conexión que cree o de una conexión existente.

Creación de una nueva conexión que almacena las credenciales de Git

En el fragmento de código siguiente se muestra un cuerpo de solicitud de ejemplo para crear una conexión que almacene las credenciales de Azure DevOps. El ejemplo completo se puede encontrar en el repositorio de ejemplos de 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)

Solicitud de ejemplo

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

Respuesta de ejemplo:

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

Obtener una lista de conexiones existentes

Use Enumerar conexiones de API para obtener una lista de las conexiones existentes para las que tiene permisos y sus propiedades.

Solicitud de ejemplo

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

Respuesta de ejemplo

{
 "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 el identificador de la conexión que desee y úselo en la API Git - Connect o Git - Update My Git Credentials API (Actualizar mis credenciales de Git ).

Consideraciones y limitaciones

  • La integración de Git mediante las API está sujeta a las mismas limitaciones que la interfaz de usuario de integración de Git.
  • La actualización de un modelo semántico mediante la API de actualización mejorada provoca una diferencia de Git después de cada actualización.

Contenido relacionado

  • Last updated on