<< Clic para mostrar Tabla de Contenidos >> Navegación:  Automatización de Procesos con poco código > Automation - ambientes de pruebas y producción > De Studio a Automation Service > Deployment > Automatización del Deployment

Introducción

La API de Automatización de Deployment le permite exportar e importar paquetes de deployment de Bizagi (archivos .bex) usando endpoints REST, en lugar de realizar este proceso de forma manual a través de la Management Console (MC).

 

Usando esta API, puede integrar deployments de Bizagi en flujos de procesos automatizados como scripts, pipelines de CI/CD o clientes de API. Todas las operaciones del deployment se ejecutan de forma asíncrona. Cuando se envía una solicitud, la API inmediatamente responde con Identificador de ejecución (ExecutionId) que se usa para monitorear el progreso hasta que la operación sea completada.

 

Cómo funciona

La API de Automatización de Deployment expone endpoints para:

•Exportar un paquete de deployment desde un ambiente de Desarrollo.

•Monitorear la ejecución de la exportación y obtener la URL de descarga del paquete generado.

•Importar un paquete de deployment a un ambiente de Pruebas o Producción.

•Monitorear el estado de la ejecución de la importación.

 

Cada operación se ejecuta de forma asíncrona y se rastrea usando un ExecutionId devuelto por la API.

 

Generar una API Key

Las solicitudes a la API de Automatización de Deployment requieren una API Key.

 

Para generar una API Key en la Management Console:

1.Despliegue el menú de Accesso Externo.

2.Seleccione Configuración de API Key.

 

 

3.Habilite la API Key utilizando el interruptor Habilitado.

4.Haga clic en el botón de calendario y seleccione la fecha de expiración.

5.Haga clic en Crear una nueva API Key.

 

 

6.Confirme la acción en la ventana emergente que aparece.

 

 

 

Consumir la API

Exportar un paquete de deployment

El endpoint de Exportación genera un paquete de deployment .bex en un ambiente de Desarrollo.

 

Características principales

•Se activa mediante una solicitud POST.

•Requiere un cuerpo de solicitud en formato JSON que defina el contenido a exportar.

•Se ejecuta de forma asíncrona.

•Devuelve un ExecutionId que se utiliza para realizar el seguimiento del progreso.

 

Endpoint

POST /api/external/v1/deployment/Export

 

Encabezados

Authorization: Bearer <API_KEY>
Content-Type: application/json

 

Cuerpo de la solicitud

Objeto JSON describiendo la configuración del deployment.

•El campo FileName es obligatorio.

•El campo Type debe ser Deployment o MicroDeployment.

 

 

Ejemplo:

 

Use el ExecutionId devuelto para monitorear la ejecución de la exportación.

 

Monitorear la ejecución de la exportación y obtener el paquete

El endpoint ExportStatus comprueba el estado actual de la exportación y, una vez finalizada, obtiene la URL de descarga del archivo .bex.

 

Endpoint

GET /api/external/v1/deployment/ExportStatus/{executionId}

 

Encabezados

Authorization: Bearer <API_KEY>

 

Cuerpo de la solicitud

No requerido.

 

Estados de exportación

La operación de exportación puede devolver los siguientes estados:

•Started: Solicitud aceptada.

•Running: Exportación en progreso.

•Done: Exportación completada correctamente.

•Error: La exportación ha fallado.

 

Mientras el estado sea Started o Running, continúe consultando el endpoint hasta que el estado cambie.

 

Respuesta (exportación completa)

{
"Status": "Done",
"SasUrlToken": "https://storage...MyDeployment.bex?...",
"ExpiryTime": "2024-01-15T11:40:00Z"
}

 

 

Importar paquete de deployment

El endpoint de Importación aplica un paquete .bex generado previamente a un ambiente de Pruebas o Producción.

 

Características principales

•Se activa mediante una solicitud POST.

•Requiere un cuerpo de solicitud en formato JSON.

•Utiliza la URL SAS generada durante la exportación.

•Se ejecuta de forma asíncrona.

•Devuelve un nuevo ExecutionId .

 

Endpoint

POST /api/external/v1/deployment/Import

 

Encabezados

Authorization: Bearer <API_KEY>
Content-Type: application/json

 

Cuerpo de la solicitud

Objeto JSON que contiene la URL SAS y una contraseña opcional.

 

Ejemplo:

 

Monitorear ejecución de la importación de paquetes

El endpoint ImportStatus monitorea el progreso de una operación de importación hasta que sea completada o falle.

 

Endpoint

GET /api/external/v1/deployment/ImportStatus/{executionId}

 

Encabezado

Authorization: Bearer <API_KEY>

 

Estados de importación

La operación de importación puede devolver los siguientes estados:

•Started: Solicitud aceptada.

•Running: Deployment en progreso.

•Done: Deployment completado correctamente.

•Error: Deployment fallido. Si el deployment falla, la respuesta incluye un mensaje que explica el motivo.

 

Interactuar con la API usando una herramienta externa

Usando un cliente de API (como Bruno):

1.Cree una solicitud utilizando el método HTTP y la URL del endpoint apropiados.

2.Agregue el cuerpo de la solicitud para su operación de Importación o Exportación.

 

 

3.Añada el encabezado de Autorización con su API Key.

 

 

4.Envíe la solicitud y obtenga el ExecutionId.

 

 

5.Cree una segunda solicitud (ExportStatus o ImportStatus) para consultar el progreso de la ejecución.

6.Envíe el ExecutionId como como parámetro de ruta.

 

 

7.Envíe la solicitud.

 

 

Ejemplos de automatización

Los siguientes ejemplos muestran cómo la API de Automatización de Deployment puede utilizarse como parte de flujos de trabajo automatizados, como scripts o pipelines de CI/CD.

 

Estos ejemplos se proporcionan únicamente con fines de referencia.

 

PowerShell

# Configuration
$devApiKey = $env:BIZAGI_DEV_API_KEY
$testApiKey = $env:BIZAGI_TEST_API_KEY
$devBaseUrl = "https://dev.mybizagi.com/api/external/v1/deployment"
$testBaseUrl = "https://test.mybizagi.com/api/external/v1/deployment"
 
# Headers
$devHeaders = @{
   "Authorization" = "Bearer $devApiKey"
   "Content-Type" = "application/json"
}
 
$testHeaders = @{
   "Authorization" = "Bearer $testApiKey"
   "Content-Type" = "application/json"
}
 
# 1. Start Export
Write-Host "Starting export..."
$exportConfig = Get-Content -Path "export-config.json" -Raw
$exportResponse = Invoke-RestMethod -Uri "$devBaseUrl/Export" -Method Post -Headers $devHeaders -Body $exportConfig
$exportExecutionId = $exportResponse.ExecutionId
 
Write-Host "Export started. ExecutionId: $exportExecutionId"
 
# 2. Monitor Export
do {
   Start-Sleep -Seconds 5
   $exportStatus = Invoke-RestMethod -Uri "$devBaseUrl/ExportStatus/$exportExecutionId" -Method Get -Headers $devHeaders
   Write-Host "Export status: $($exportStatus.Status) - $($exportStatus.Message)"
} while ($exportStatus.Status -eq "Started" -or $exportStatus.Status -eq "Running")
 
if ($exportStatus.Status -ne "Done") {
   Write-Error "Export failed: $($exportStatus.Message)"
   exit 1
}
 
$sasUrl = $exportStatus.SasUrlToken
Write-Host "Export completed. SAS URL obtained."
 
# 3. Start Import
Write-Host "Starting import into Test environment..."
$importConfig = @{
   SasUrlToken = $sasUrl
   Password = "SecurePass123"
} | ConvertTo-Json
 
$importResponse = Invoke-RestMethod -Uri "$testBaseUrl/Import" -Method Post -Headers $testHeaders -Body $importConfig
$importExecutionId = $importResponse.ExecutionId
 
Write-Host "Import started. ExecutionId: $importExecutionId"
 
# 4. Monitor Import
do {
   Start-Sleep -Seconds 10
   $importStatus = Invoke-RestMethod -Uri "$testBaseUrl/ImportStatus/$importExecutionId" -Method Get -Headers $testHeaders
   Write-Host "Import status: $($importStatus.Status) - $($importStatus.Message)"
} while ($importStatus.Status -eq "Started" -or $importStatus.Status -eq "Running")
 
if ($importStatus.Status -ne "Done") {
   Write-Error "Import failed: $($importStatus.Message)"
   exit 1
}
 
Write-Host "Automated deployment completed successfully!"
``

 

Python

import os
import time
import json
import requests
from typing import Optional
 
# Configuration
DEV_API_KEY = os.getenv('BIZAGI_DEV_API_KEY')
TEST_API_KEY = os.getenv('BIZAGI_TEST_API_KEY')
DEV_BASE_URL = 'https://dev.mybizagi.com/api/external/v1/deployment'
TEST_BASE_URL = 'https://test.mybizagi.com/api/external/v1/deployment'
 
 
def get_headers(api_key: str) -> dict:
   return {
       'Authorization': f'Bearer {api_key}',
       'Content-Type': 'application/json'
   }
 
 
def start_export(base_url: str, api_key: str, config: dict) -> str:
   """Starts an export operation and returns the ExecutionId"""
   print('Starting export...')
   response = requests.post(
       f'{base_url}/Export',
       headers=get_headers(api_key),
       json=config
   )
   response.raise_for_status()
   execution_id = response.json()['ExecutionId']
   print(f'Export started. ExecutionId: {execution_id}')
   return execution_id
 
 
def poll_export_status(base_url: str, api_key: str, execution_id: str) -> str:
   """Polls the export until completion and returns the SAS URL"""
  while True:
       time.sleep(5)
       response = requests.get(
           f'{base_url}/ExportStatus/{execution_id}',
           headers=get_headers(api_key)
       )
       response.raise_for_status()
       status = response.json()
 
       print(f"Export status: {status['Status']} - {status['Message']}")
 
      if status['Status'] == 'Done':
           return status['SasUrlToken']
       elif status['Status'] == 'Error':
          raise Exception(f"Export failed: {status['Message']}")
 
 
def start_import(
   base_url: str,
   api_key: str,
   sas_url: str,
   password: Optional[str] = None
) -> str:
   """Starts an import operation and returns the ExecutionId"""
   print('Starting import...')
   config = {'SasUrlToken': sas_url}
  if password:
       config['Password'] = password
 
   response = requests.post(
       f'{base_url}/Import',
       headers=get_headers(api_key),
       json=config
   )
   response.raise_for_status()
   execution_id = response.json()['ExecutionId']
   print(f'Import started. ExecutionId: {execution_id}')
   return execution_id
 
 
def poll_import_status(base_url: str, api_key: str, execution_id: str):
   """Polls the import until completion"""
  while True:
       time.sleep(10)
       response = requests.get(
           f'{base_url}/ImportStatus/{execution_id}',
           headers=get_headers(api_key)
       )
 
      if response.status_code == 404:
          raise Exception('Import execution not found')
 
       response.raise_for_status()
       status = response.json()
 
       print(f"Import status: {status['Status']} - {status['Message']}")
 
      if status['Status'] == 'Done':
           return
       elif status['Status'] == 'Error':
          raise Exception(f"Import failed: {status['Message']}")
 
 
def main():
   # 1. Load export configuration
  with open('export-config.json', 'r') as f:
       export_config = json.load(f)
 
   # 2. Execute export
   export_execution_id = start_export(
       DEV_BASE_URL,
       DEV_API_KEY,
       export_config
   )
   sas_url = poll_export_status(
       DEV_BASE_URL,
       DEV_API_KEY,
       export_execution_id
   )
   print('Export completed. SAS URL obtained.')
 
   # 3. Execute import
   import_execution_id = start_import(
       TEST_BASE_URL,
       TEST_API_KEY,
       sas_url,
       'SecurePass123'
   )
   poll_import_status(
       TEST_BASE_URL,
       TEST_API_KEY,
       import_execution_id
   )
 
   print('Automated deployment completed successfully!')
 
 
if __name__ == '__main__':
   main()

 

Bash (usando curl)

#!/bin/bash
set -e
 
# Configuration
DEV_API_KEY="${BIZAGI_DEV_API_KEY}"
TEST_API_KEY="${BIZAGI_TEST_API_KEY}"
DEV_BASE_URL="https://dev.mybizagi.com/api/external/v1/deployment"
TEST_BASE_URL="https://test.mybizagi.com/api/external/v1/deployment"
 
# Function to start export
start_export() {
   echo "Starting export..."
   response=$(curl -s -X POST "${DEV_BASE_URL}/Export" \
       -H "Authorization: Bearer ${DEV_API_KEY}" \
       -H "Content-Type: application/json" \
       -d @export-config.json)
 
   execution_id=$(echo $response | jq -r '.ExecutionId')
   echo "Export started. ExecutionId: ${execution_id}"
   echo $execution_id
}
 
# Function to monitor export
wait_for_export() {
   local execution_id=$1
   local status="Started"
 
   while [[ "$status" == "Started" || "$status" == "Running" ]]; do
       sleep 5
       response=$(curl -s -X GET "${DEV_BASE_URL}/ExportStatus/${execution_id}" \
           -H "Authorization: Bearer ${DEV_API_KEY}")
 
       status=$(echo $response | jq -r '.Status')
      message=$(echo $response | jq -r '.Message')
       echo "Export status: ${status} - ${message}"
   done
 
  if [[ "$status" != "Done" ]]; then
       echo "Export failed: ${message}"
       exit 1
   fi
 
   sas_url=$(echo $response | jq -r '.SasUrlToken')
   echo $sas_url
}
 
# Function to start import
start_import() {
   local sas_url=$1
   echo "Starting import into Test environment..."
 
   response=$(curl -s -X POST "${TEST_BASE_URL}/Import" \
       -H "Authorization: Bearer ${TEST_API_KEY}" \
       -H "Content-Type: application/json" \
       -d "{\"SasUrlToken\": \"${sas_url}\", \"Password\": \"SecurePass123\"}")
 
   execution_id=$(echo $response | jq -r '.ExecutionId')
   echo "Import started. ExecutionId: ${execution_id}"
   echo $execution_id
}
 
# Function to monitor import
wait_for_import() {
   local execution_id=$1
   local status="Started"
 
   while [[ "$status" == "Started" || "$status" == "Running" ]]; do
       sleep 10
       response=$(curl -s -X GET "${TEST_BASE_URL}/ImportStatus/${execution_id}" \
           -H "Authorization: Bearer ${TEST_API_KEY}")
 
       status=$(echo $response | jq -r '.Status')
      message=$(echo $response | jq -r '.Message')
       echo "Import status: ${status} - ${message}"
   done
 
  if [[ "$status" != "Done" ]]; then
       echo "Import failed: ${message}"
       exit 1
   fi
}
 
# Main script
main() {
   # 1. Export
   export_execution_id=$(start_export)
   sas_url=$(wait_for_export "$export_execution_id")
   echo "Export completed. SAS URL obtained."
 
   # 2. Import
   import_execution_id=$(start_import "$sas_url")
   wait_for_import "$import_execution_id"
 
   echo "Automated deployment completed successfully!"
}
 
main

 

CI/CD integration (Azure DevOps)

# azure-pipelines.yml
trigger:
 branches:
   include:
     - main
 
variables:
 # Variable group containing DEV_API_KEY and TEST_API_KEY
 - group: bizagi-api-keys
 
stages:
 - stage: Export
   displayName: 'Export from Development'
   jobs:
     - job: ExportPackage
       displayName: 'Export Deployment Package'
       pool:
         vmImage: 'ubuntu-latest'
       steps:
         - task: PowerShell@2
           displayName: 'Export and Monitor'
           inputs:
             targetType: 'inline'
             script: |
               $headers = @{

 

Export configuration file (export-config.json)

{
 "Workflows": [
   {
     "DisplayName": "MyProcess",
     "Version": "1.0",
     "Id": "4e2ce804-9c19-4e29-966c-142663906715"
   }
 ],
 "ExperienceObjects": [],
 "Options": {
   "SubProcess": true,
   "EnvironmentParamsValue": true,
   "Business configuration": true,
   "Holidays": false,
   "Dimensions": false,
   "Themes": true,
   "Usergroups": true,
   "Workcalendar": true,
   "Custom job": true,
   "User Properties": false,
   "AuthOption": false,
   "Assemblies": false,
   "Oauth2 configuration": false,
   "Organization": false,
   "Org Tables": {
     "Position": false,
     "Skills": false,
     "Location": false,
     "Area": false,
     "Role": false,
     "Organization": false
   }
 },
 "Trigger": [],
 "Description": "Automated deployment from CI/CD",
{

 

Consideraciones importantes

•Solo una operación de Exportación y una operación de Importación pueden ejecutarse al mismo tiempo por ambiente.

•Se debe acceder a las URL de descarga antes de su tiempo de expiración.

•No está permitido importar archivos desde enlaces públicos externos.

•La sincronización de datos no está incluida en el proceso de deployment.

Last Updated 7/19/2026 6:54:58 PM