Como migrar do Azure DevOps com o Actions Importer

Neste artigo

Aviso legal

As instruções abaixo orientarão você na configuração do ambiente para usar o Actions Importer para migrar os pipelines do Azure DevOps para o Actions.

  • Uma conta ou uma organização do Azure DevOps com projetos e pipelines que você deseja converter em fluxos de trabalho do Actions.
  • Acesso para criar um personal access token do Azure DevOps para sua conta ou organização.
  • Um ambiente em que seja possível executar contêineres baseados no Linux e instalar as ferramentas necessárias.

    • O Docker está instalado e em execução.

    • A CLI do está instalada.

    Observação

    A CLI e o contêiner do Actions Importer não precisam ser instalados no mesmo servidor que a plataforma de CI.

Há algumas limitações na migração do Azure DevOps para o Actions com o Actions Importer:

  • O Actions Importer exige a versão 5.0 da API do Azure DevOps, disponível no Azure DevOps Services ou no Azure DevOps Server 2019. As versões mais antigas do Azure DevOps Server não são compatíveis.
  • As tarefas que são adicionadas implicitamente a um pipeline do Azure DevOps, como o check-out do código-fonte, podem ser adicionadas a uma auditoria do Actions Importer como um nome GUID. Para localizar o nome da tarefa amigável de um GUID, use a seguinte URL: https://dev.azure.com/:organization/_apis/distributedtask/tasks/:guid.

Alguns constructos do Azure DevOps precisam ser migrados manualmente do Azure DevOps para as configurações do Actions. Estão incluídos:

  • Segredos de organização, repositório e ambiente
  • Conexões de serviço como o OIDC Connect, o Apps e os personal access tokens
  • Tarefas desconhecidas
  • Agentes auto-hospedados
  • Ambientes
  • Aprovações pré-implantação

Para saber mais sobre migrações manuais, confira Migrar do Azure Pipelines para o Actions.

O Actions Importer não dá suporte à migração das seguintes tarefas:

  • Portões pré-implantação
  • Portões pós-implantação
  • Aprovações pós-implantação
  • Alguns gatilhos de recurso

  1. Instale a extensão da CLI do Actions Importer:

    Bash
    gh extension install /gh-actions-importer

  2. Verifique se a extensão foi instalada:

    $ gh actions-importer -h
Options:
  -?, -h, --help  Show help and usage information

Commands:
  update     Update to the latest version of  Actions Importer.
  version    Display the version of  Actions Importer.
  configure  Start an interactive prompt to configure credentials used to authenticate with your CI server(s).
  audit      Plan your CI/CD migration by analyzing your current CI/CD footprint.
  forecast   Forecast  Actions usage from historical pipeline utilization.
  dry-run    Convert a pipeline to a  Actions workflow and output its yaml file.
  migrate    Convert a pipeline to a  Actions workflow and open a pull request with the changes.

O comando configure da CLI é usado para definir as credenciais e as opções obrigatórias para o Actions Importer ao trabalhar com o Azure DevOps e o .

  1. Crie um personal access token (classic) do . Para saber mais, confira Gerenciar seus tokens de acesso pessoal.

    O token precisa ter o escopo workflow.

    Depois de criar o token, copie-o e salve-o em um local seguro para uso posterior.

  2. Crie um personal access token do Azure DevOps. Para saber mais, confira Usar personal access tokens na documentação do Azure DevOps. O token precisa ter os seguintes escopos:

    • Pool de agentes: Read
    • Build: Read
    • Código: Read
    • Versão: Read
    • Conexões de serviço: Read
    • Grupos de tarefas: Read
    • Grupo de variáveis: Read

    Depois de criar o token, copie-o e salve-o em um local seguro para uso posterior.

  3. No terminal, execute o comando da CLI configure do Actions Importer:

    gh actions-importer configure

    O comando configure solicitará que você insira as seguintes informações:

    • Em "Quais provedores de CI você está configurando?", use as teclas de direção para selecionar Azure DevOps, pressione Espaço para fazer a seleção e pressione Enter.
    • Em "Personal access token para ", insira o valor do personal access token (classic) criado anteriormente e pressione Enter.
    • Para "Base url of the instance", pressione Enter para aceitar o valor padrão (https://.com).
    • Em "Personal access token para Azure DevOps", insira o valor do personal access token do Azure DevOps criado anteriormente e pressione ENTER.
    • Em "URL base da instância do Azure DevOps", pressione ENTER para aceitar o valor padrão (https://dev.azure.com).
    • Em "Nome da organização do Azure DevOps", insira o nome da sua organização do Azure DevOps e pressione ENTER.
    • Em "Nome do projeto do Azure DevOps", insira o nome do projeto do Azure DevOps e pressione ENTER.

    Um exemplo do comando configure é mostrado abaixo:

    $ gh actions-importer configure
✔ Which CI providers are you configuring?: Azure DevOps
Enter the following values (leave empty to omit):
✔ Personal access token for : ***************
✔ Base url of the  instance: https://.com
✔ Personal access token for Azure DevOps: ***************
✔ Base url of the Azure DevOps instance: https://dev.azure.com
✔ Azure DevOps organization name: :organization
✔ Azure DevOps project name: :project
Environment variables successfully updated.

  4. No terminal, execute o comando update da CLI do Actions Importer para se conectar ao Packages Container registry e verifique se a imagem de contêiner foi atualizada para a última versão:

    gh actions-importer update

    A saída do comando será semelhante ao seguinte:

    Updating ghcr.io/actions-importer/cli:latest...
ghcr.io/actions-importer/cli:latest up-to-date

Use o comando audit para obter uma exibição de alto nível de todos os projetos de uma organização do Azure DevOps.

O comando audit executa as seguintes etapas:

  1. Busca todos os projetos definidos em uma organização do Azure DevOps.
  2. Converte cada pipeline no fluxo de trabalho equivalente do Actions.
  3. Gera um relatório que resume a possibilidade do nível de integridade e complexidade de uma migração com o Actions Importer.

Para executar uma auditoria de uma organização do Azure DevOps, execute o seguinte comando no terminal:

gh actions-importer audit azure-devops --output-dir tmp/audit

Os arquivos do diretório de saída especificado contêm os resultados da auditoria. Confira o arquivo audit_summary.md para ver um resumo dos resultados da auditoria.

O resumo da auditoria contém as seções a seguir.

A seção "Pipelines" contém estatísticas de alto nível sobre a taxa de conversão feita pelo Actions Importer.

Veja abaixo alguns termos importantes que podem aparecer na seção "Pipelines":

  • Os pipelines Bem-sucedidos tiveram 100% dos constructos e itens individuais convertidos automaticamente nos equivalentes do Actions.
  • Os pipelines parcialmente bem-sucedidos tiveram todos os constructos de pipeline convertidos, porém, houve alguns itens individuais que não foram convertidos automaticamente nos Actions equivalentes.
  • Os pipelines Sem suporte são tipos de definição que não têm suporte no Actions Importer.
  • Os pipelines com falha encontraram um erro fatal ao serem convertidos. Isso pode ocorrer por uma das seguintes razões:
    • O pipeline foi originalmente configurado de forma incorreta e inválida.
    • O Actions Importer encontrou um erro interno ao convertê-lo.
    • Houve uma resposta de rede malsucedida que tornou o pipeline inacessível, o que geralmente ocorre devido a credenciais inválidas.

A seção "Etapas de compilação" contém uma visão geral das etapas de compilação individuais usadas em todos os pipelines e indica quantas delas foram convertidas automaticamente pelo Actions Importer.

Veja abaixo alguns termos importantes que podem aparecer na seção "Etapas de compilação":

  • Uma etapa de compilação conhecida foi convertida automaticamente em uma ação equivalente.
  • Uma etapa de compilação desconhecida não foi convertida automaticamente em uma ação equivalente.
  • Uma etapa de compilação sem suporte é aquela que:
    • Fundamentalmente, não tem suporte no Actions.
    • Foi configurada de maneira incompatível com o Actions.
  • Uma ação é uma lista das ações que foram usadas nos fluxos de trabalho convertidos. Isso pode ser importante para:
    • Se você usar o Enterprise Server, reunir a lista de ações a serem sincronizadas com a sua instância.
    • Definir uma lista de permissões no nível da organização das ações que são usadas. Essa lista de ações é abrangente e inclui as ações que as equipes de segurança ou conformidade podem precisar analisar.

A seção "Tarefas manuais" contém uma visão geral das tarefas que o Actions Importer não consegue executar automaticamente e que precisam ser realizadas de maneira manual.

Veja abaixo alguns termos importantes que podem aparecer na seção "Tarefas manuais":

  • Um segredo é um repositório ou um segredo no nível da organização que é usado nos pipelines convertidos. Esses segredos devem ser criados manualmente no Actions para que os pipelines funcionem de maneira correta. Para saber mais, confira Usar segredos em ações do .
  • Um executor auto-hospedado refere-se a um rótulo de um executor que é referenciado em um pipeline convertido e que não é hospedado no . Será necessário definir manualmente esses executores para que os pipelines funcionem de maneira correta.

A seção final do relatório de auditoria fornece um manifesto de todos os arquivos que foram gravados em disco durante a auditoria.

Cada arquivo de pipeline tem uma variedade de arquivos contidos na auditoria, incluindo:

  • O pipeline original como foi definido no .
  • Todas as respostas de rede usadas para converter o pipeline.
  • O arquivo de fluxo de trabalho convertido.
  • Rastreamentos de pilha que podem ser usados para solucionar problemas de uma conversão de pipeline com falha.

Além disso, o arquivo workflow_usage.csv contém uma lista separada por vírgula de todas as ações, todos os segredos e todos os executores usados pelos pipelines convertidos com sucesso. Isso pode ser útil para determinar quais fluxos de trabalho usam quais ações, segredos ou executores e para executar revisões de segurança.

Use o comando forecast para prever o uso potencial do Actions calculando métricas de execuções de pipeline concluídas no Azure DevOps.

Para executar uma previsão do uso potencial do Actions, execute o comando a seguir no terminal. Por padrão, o Actions Importer inclui os sete dias anteriores no relatório de previsão.

gh actions-importer forecast azure-devops --output-dir tmp/forecast_reports

O arquivo forecast_report.md no diretório de saída especificado contém os resultados da previsão.

Veja abaixo alguns termos importantes que podem aparecer no relatório de previsão:

  • A contagem de trabalhos é o número total de trabalhos concluídos.

  • A contagem de pipelines é o número de pipelines exclusivos usados.

  • O tempo de execução descreve o tempo gasto por um executor em um trabalho. Essa métrica pode ser usada para auxiliar no plano de custo dos executores hospedados pelo .

    Ela está correlacionada ao custo possível esperado com o Actions. Isso pode variar de acordo com o hardware usado para esses minutos. Use a calculadora de preços do Actions para estimar os custos.

  • As métricas de tempo de espera descrevem o tempo gasto por um trabalho aguardando um executor ficar disponível para executá-lo.

  • As métricas de trabalhos simultâneos descrevem a quantidade de trabalhos em execução a qualquer momento. Elas podem ser usadas para definir o número de executores que você deve configurar.

Além disso, essas métricas são definidas para cada fila de executores do Azure DevOps. Isso é especialmente útil quando há uma combinação de executores hospedados ou auto-hospedados ou quando há computadores de especificação alta ou baixa, a fim de ver métricas específicas para diferentes tipos de executores.

Use o comando dry-run para converter um pipeline do Azure DevOps em um fluxo de trabalho equivalente do Actions. Uma simulação cria os arquivos de saída em um diretório especificado, mas não abre uma solicitação de pull para migrar o pipeline.

No caso de qualquer item que o Actions Importer não tenha conseguido converter automaticamente, como etapas de build desconhecidas ou um pipeline parcialmente bem-sucedido, o ideal é criar transformadores personalizados para personalizar ainda mais o processo de conversão. Para saber mais, confira Como estender o Importador de Actions com transformadores personalizados.

Para executar uma simulação de migração do pipeline de build do Azure DevOps para o Actions, execute o comando a seguir no terminal, substituindo pipeline_id pela ID do pipeline que você está convertendo.

gh actions-importer dry-run azure-devops pipeline --pipeline-id :pipeline_id --output-dir tmp/dry-run

É possível ver os logs da simulação e os arquivos de fluxos de trabalho convertidos no diretório de saída especificado.

Para executar uma simulação de migração dos pipelines do Azure DevOps para o Actions, execute o comando a seguir no terminal, substituindo pipeline_id pela ID do pipeline que você está convertendo.

gh actions-importer dry-run azure-devops release --pipeline-id :pipeline_id --output-dir tmp/dry-run

É possível ver os logs da simulação e os arquivos de fluxos de trabalho convertidos no diretório de saída especificado.

Use o comando migrate para converter um pipeline do Azure DevOps e abrir uma solicitação de pull com o fluxo de trabalho equivalente do Actions.

Para migrar um pipeline de build do Azure DevOps para o Actions, execute o comando a seguir no terminal, substituindo o valor target-url pela URL do repositório e pipeline_id pela ID do pipeline que você está convertendo.

gh actions-importer migrate azure-devops pipeline --pipeline-id :pipeline_id --target-url https://.com/octo-org/octo-repo --output-dir tmp/migrate

A saída do comando inclui a URL da solicitação de pull que adiciona o fluxo de trabalho convertido ao repositório. Um exemplo de uma saída bem-sucedida é semelhante ao seguinte:

$ gh actions-importer migrate azure-devops pipeline --target-url https://.com/octo-org/octo-repo --output-dir tmp/migrate --azure-devops-project my-azure-devops-project
[2022-08-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20220916-014033.log'
[2022-08-20 22:08:20] Pull request: 'https://.com/octo-org/octo-repo/pull/1'

Para migrar um pipeline de lançamento do Azure DevOps para o Actions, execute o comando a seguir no terminal, substituindo o valor target-url pela URL do repositório e pipeline_id pela ID do pipeline que você está convertendo.

gh actions-importer migrate azure-devops release --pipeline-id :pipeline_id --target-url https://.com/octo-org/octo-repo --output-dir tmp/migrate

A saída do comando inclui a URL da solicitação de pull que adiciona o fluxo de trabalho convertido ao repositório. Um exemplo de uma saída bem-sucedida é semelhante ao seguinte:

$ gh actions-importer migrate azure-devops release --target-url https://.com/octo-org/octo-repo --output-dir tmp/migrate --azure-devops-project my-azure-devops-project
[2022-08-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20220916-014033.log'
[2022-08-20 22:08:20] Pull request: 'https://.com/octo-org/octo-repo/pull/1'

A saída de uma execução bem-sucedida do comando migrate contém um link para a nova solicitação de pull que adiciona o fluxo de trabalho convertido ao seu repositório.

Alguns elementos importantes da solicitação de pull incluem:

  • Na descrição da solicitação de pull, uma seção chamada Etapas manuais, que lista as etapas que você precisa concluir manualmente para concluir a migração dos pipelines para o Actions. Por exemplo, esta seção pode solicitar a criação dos segredos usados nos fluxos de trabalho.
  • O arquivo de fluxos de trabalho convertido. Selecione a guia Files changed na pull request para ver o arquivo de fluxo de trabalho que será adicionado ao repositório do .

Quando terminar de inspecionar a pull request, você poderá mesclá-la para adicionar o fluxo de trabalho ao repositório do .

Esta seção contém informações de referência sobre variáveis de ambiente, argumentos opcionais e a sintaxe com suporte durante o uso do Actions Importer para migração do Azure DevOps.

O Actions Importer usa variáveis de ambiente para a configuração de autenticação. Essas variáveis são definidas durante o processo de configuração com o comando configure. Para obter mais informações, confira a seção Como configurar as credenciais.

O Actions Importer usa as seguintes variáveis de ambiente para se conectar à instância do Azure DevOps:

  • _ACCESS_TOKEN: o personal access token (classic) usado para criar solicitações de pull com um fluxo de trabalho convertido (o escopo workflow é necessário).
  • _INSTANCE_URL: a URL para a instância de destino do (por exemplo, https://.com).
  • AZURE_DEVOPS_ACCESS_TOKEN: o personal access token usado para autenticação na sua instância do Azure DevOps. Esse token exige os seguintes escopos:
    • Build: Read
    • Pools de agentes: Read
    • Código: Read
    • Versão: Read
    • Conexões de serviço: Read
    • Grupos de tarefas: Read
    • Grupo de variáveis: Read
  • AZURE_DEVOPS_PROJECT: o nome do projeto ou o GUID a ser usado ao migrar um pipeline. Caso você deseje executar uma auditoria em todos os projetos, isso é opcional.
  • AZURE_DEVOPS_ORGANIZATION: o nome da organização da instância do Azure DevOps.
  • AZURE_DEVOPS_INSTANCE_URL: a URL para a instância do Azure DevOps, como https://dev.azure.com.

Essas variáveis de ambiente podem ser especificadas em um arquivo .env.local carregado pelo Actions Importer quando ele é executado.

Há argumentos opcionais que você pode usar com os subcomandos do Actions Importer para personalizar sua migração.

Use o argumento --source-file-path com os subcomandos forecast, dry-run ou migrate.

Por padrão, o Actions Importer busca o conteúdo do pipeline no controle do código-fonte. O argumento --source-file-path instrui o Actions Importer a usar o caminho do arquivo de origem especificado.

Por exemplo:

gh actions-importer dry-run azure-devops pipeline --output-dir ./output/ --source-file-path ./path/to/azure_devops/pipeline.yml

Use o argumento --config-file-path com os subcomandos audit, dry-run e migrate.

Por padrão, o Actions Importer busca o conteúdo do pipeline no controle do código-fonte. O argumento --config-file-path instrui o Actions Importer a usar o caminho dos arquivos de origem especificados.

O argumento --config-file-path também pode ser usado para especificar para qual repositório um fluxo de trabalho reutilizável convertido ou uma ação composta deve ser migrada.

Neste exemplo, o Actions Importer usa o arquivo de configuração YAML especificado como o arquivo de origem para executar uma auditoria.

gh actions-importer audit azure-devops pipeline --output-dir ./output/ --config-file-path ./path/to/azure_devops/config.yml

Para auditar uma instância do Azure DevOps usando um arquivo de configuração, o arquivo precisa estar no seguinte formato e cada repository_slug precisa ser exclusivo:

source_files:
  - repository_slug: azdo-project/1
    path: file.yml
  - repository_slug: azdo-project/2
    paths: path.yml

Você pode gerar o repository_slug para um pipeline combinando o nome da organização do Azure DevOps, o nome do projeto e a ID do pipeline. Por exemplo, my-organization-name/my-project-name/42.

Neste exemplo, o Actions Importer usa o arquivo de configuração YAML especificado como o arquivo de origem a fim de executar uma simulação.

O pipeline é selecionado pela correspondência do repository_slug no arquivo de configuração com o valor das opções --azure-devops-organization e --azure-devops-project. Em seguida, path é usado para efetuar pull do arquivo de origem especificado.

gh actions-importer dry-run azure-devops pipeline --output-dir ./output/ --config-file-path ./path/to/azure_devops/config.yml

Actions Importer usa o arquivo YAML fornecido ao argumento --config-file-path para determinar o repositório para o qual os fluxos de trabalho reutilizáveis convertidos e as ações compostas são migrados.

Para começar, você deve executar uma auditoria sem o argumento --config-file-path:

gh actions-importer audit azure-devops --output-dir ./output/

A saída desse comando conterá um arquivo chamado config.yml que contém uma lista de todos os fluxos de trabalho reutilizáveis e ações compostas que foram convertidas por Actions Importer. Por exemplo, o arquivo config.yml pode ter o seguinte conteúdo:

reusable_workflows:
  - name: my-reusable-workflow.yml
    target_url: https://.com/octo-org/octo-repo
    ref: main

composite_actions:
  - name: my-composite-action.yml
    target_url: https://.com/octo-org/octo-repo
    ref: main

Você pode usar esse arquivo para especificar a qual repositório e ref um fluxo de trabalho reutilizável ou uma ação composta deve ser adicionado. Em seguida, você pode usar o argumento --config-file-path para fornecer o arquivo config.yml para Actions Importer. Por exemplo, você pode usar esse arquivo ao executar um comando migrate para abrir uma solicitação de pull para cada repositório exclusivo definido no arquivo de configuração:

gh actions-importer migrate azure-devops pipeline --config-file-path config.yml --target-url https://.com/my-org/my-repo

A tabela a seguir mostra os tipos de propriedades que o Actions Importer pode converter no momento.

Azure PipelinesActionsStatus
condition
  • jobs.<job_id>.if
  • jobs.<job_id>.steps[*].if
Com suporte
contêiner
  • jobs.<job_id>.container
  • jobs.<job_id>.name
Com suporte
continuousIntegration
  • on.<push>.<branches>
  • on.<push>.<tags>
  • on.<push>.paths
Com suporte
trabalho
  • jobs.<job_id>
Com suporte
pullRequest
  • on.<pull_request>.<branches>
  • on.<pull_request>.paths
Com suporte
preparar
  • jobs
Com suporte
etapas
  • jobs.<job_id>.steps
Com suporte
estratégia
  • jobs.<job_id>.strategy.fail-fast
  • jobs.<job_id>.strategy.max-parallel
  • jobs.<job_id>.strategy.matrix
Com suporte
timeoutInMinutes
  • jobs.<job_id>.timeout-minutes
Com suporte
variáveis
  • env
  • jobs.<job_id>.env
  • jobs.<job_id>.steps.env
Com suporte
manual deployment
  • jobs.<job_id>.environment
Suporte parcial
pool
  • runners
  • self hosted runners
Suporte parcial
services
  • jobs.<job_id>.services
Suporte parcial
estratégia
  • jobs.<job_id>.strategy
Suporte parcial
gatilhos
  • on
Suporte parcial
pullRequest
  • on.<pull_request>.<tags>
Sem suporte
schedules
  • on.schedule
  • on.workflow_run
Sem suporte
gatilhos
  • on.<event_name>.types
Sem suporte

Para obter mais informações sobre as tarefas com suporte do Azure DevOps, confira o repositório /gh-actions-importer.

O Actions Importer usa o mapeamento da tabela abaixo para converter as variáveis de ambiente padrão do Azure DevOps no equivalente mais próximo do Actions.

Azure PipelinesActions
$(Agent.BuildDirectory)${{ runner.workspace }}
$(Agent.HomeDirectory)${{ env.HOME }}
$(Agent.JobName)${{ .job }}
$(Agent.OS)${{ runner.os }}
$(Agent.ReleaseDirectory)${{ .workspace}}
$(Agent.RootDirectory)${{ .workspace }}
$(Agent.ToolsDirectory)${{ runner.tool_cache }}
$(Agent.WorkFolder)${{ .workspace }}
$(Build.ArtifactStagingDirectory)${{ runner.temp }}
$(Build.BinariesDirectory)${{ .workspace }}
$(Build.BuildId)${{ .run_id }}
$(Build.BuildNumber)${{ .run_number }}
$(Build.DefinitionId)${{ .workflow }}
$(Build.DefinitionName)${{ .workflow }}
$(Build.PullRequest.TargetBranch)${{ .base_ref }}
$(Build.PullRequest.TargetBranch.Name)${{ .base_ref }}
$(Build.QueuedBy)${{ .actor }}
$(Build.Reason)${{ .event_name }}
$(Build.Repository.LocalPath)${{ .workspace }}
$(Build.Repository.Name)${{ .repository }}
$(Build.Repository.Provider)
$(Build.Repository.Uri)${{ .server.url }}/${{ .repository }}
$(Build.RequestedFor)${{ .actor }}
$(Build.SourceBranch)${{ .ref }}
$(Build.SourceBranchName)${{ .ref }}
$(Build.SourceVersion)${{ .sha }}
$(Build.SourcesDirectory)${{ .workspace }}
$(Build.StagingDirectory)${{ runner.temp }}
$(Pipeline.Workspace)${{ runner.workspace }}
$(Release.DefinitionEnvironmentId)${{ .job }}
$(Release.DefinitionId)${{ .workflow }}
$(Release.DefinitionName)${{ .workflow }}
$(Release.Deployment.RequestedFor)${{ .actor }}
$(Release.DeploymentID)${{ .run_id }}
$(Release.EnvironmentId)${{ .job }}
$(Release.EnvironmentName)${{ .job }}
$(Release.Reason)${{ .event_name }}
$(Release.RequestedFor)${{ .actor }}
$(System.ArtifactsDirectory)${{ .workspace }}
$(System.DefaultWorkingDirectory)${{ .workspace }}
$(System.HostType)build
$(System.JobId)${{ .job }}
$(System.JobName)${{ .job }}
$(System.PullRequest.PullRequestId)${{ .event.number }}
$(System.PullRequest.PullRequestNumber)${{ .event.number }}
$(System.PullRequest.SourceBranch)${{ .ref }}
$(System.PullRequest.SourceRepositoryUri)${{ .server.url }}/${{ .repository }}
$(System.PullRequest.TargetBranch)${{ .event.base.ref }}
$(System.PullRequest.TargetBranchName)${{ .event.base.ref }}
$(System.StageAttempt)${{ .run_number }}
$(System.TeamFoundationCollectionUri)${{ .server.url }}/${{ .repository }}
$(System.WorkFolder)${{ .workspace }}

Você pode transformar os modelos do Azure DevOps com o Actions Importer.

O Actions Importer pode transformar modelos do Azure DevOps com algumas limitações.

  • Os modelos do Azure DevOps usados nas chaves stages, deployments e jobs são convertidos em fluxos de trabalho reutilizáveis no Actions. Para saber mais, confira Reutilizar fluxos de trabalho.
  • Os modelos do Azure DevOps usados na chave steps são convertidos em ações compostas. Para saber mais, confira Criar uma ação composta.
  • Se você tiver modelos de trabalho que referenciam outros modelos de trabalho, i Actions Importer converterá os modelos em fluxos de trabalho reutilizáveis. Como os fluxos de trabalho reutilizáveis não podem referenciar outros fluxos de trabalho reutilizáveis, essa é uma sintaxe inválida no Actions. Você precisa corrigir manualmente os fluxos de trabalho aninhados reutilizáveis.
  • Se um modelo referencia uma organização externa do Azure DevOps ou um repositório , use a opção --credentials-file para fornecer credenciais para acessar esse modelo. Para saber mais, confira Argumentos e configurações complementares.
  • Você pode gerar o YAML dinamicamente usando expressões each com as seguintes advertências:
    • Não há suporte para blocos each aninhados, e eles fazem com que o bloco pai each não tenha suporte.
    • As condições each e if contidas são avaliadas em tempo de transformação, pois o Actions não dá suporte a esse estilo de inserção.
    • Não há suporte para blocos elseif. Se essa funcionalidade for necessária, você precisará corrigi-las manualmente.
    • Há suporte para blocos if aninhados, mas não há suporte para blocos if/elseif/else aninhados em uma condição if.
    • Não há suporte para blocos if que usam variáveis predefinidas do Azure DevOps.

O Actions Importer dá suporte aos modelos listados na tabela abaixo.

Azure PipelinesActionsStatus
Extensão de um modeloReusable workflowCom suporte
Modelos de trabalhoReusable workflowCom suporte
Modelos de estágioReusable workflowCom suporte
Modelos de etapaComposite actionCom suporte
Grupos de tarefas no editor clássicoVariaCom suporte
Modelos em uma organização, um projeto ou um repositório diferentes do Azure DevOpsVariaCom suporte
Modelos em um repositórioVariaCom suporte
Modelos de variávelenvCom suporte
Inserção condicionalCondições if no trabalho/nas etapasSuporte parcial
Inserção iterativaNão aplicávelSuporte parcial
Modelos com parâmetrosVariaSuporte parcial

O Actions Importer pode extrair modelos com caminhos de arquivo relativos ou dinâmicos com expressões de variáveis, de parâmetros e iterativas no nome do arquivo. No entanto, é preciso haver um conjunto de valores padrão.

# File: azure-pipelines.yml
variables:
- template: 'templates/vars.yml'

steps:
- template: "./templates/$"

# File: templates/vars.yml
variables:
  one: 'simple_step.yml'

parameters:
- name: template
  type: string
  default: simple_step.yml

steps:
- template: "./templates/${{ parameters.template }}"

parameters:
- name: steps
  type: object
  default:
  - build_step
  - release_step
steps:
- ${{ each step in parameters.steps }}:
    - template: "$-variables.yml"

O Actions Importer dá suporte aos parâmetros listados na tabela abaixo.

Azure PipelinesActionsStatus
stringinputs.stringCom suporte
númeroinputs.numberCom suporte
booleanoinputs.booleanCom suporte
objetoinputs.string com a expressão fromJSONSuporte parcial
EtapastepSuporte parcial
stepListstepSuporte parcial
trabalhojobSuporte parcial
jobListjobSuporte parcial
implantaçãojobSuporte parcial
deploymentListjobSuporte parcial
prepararjobSuporte parcial
stageListjobSuporte parcial

Observação

Um modelo usado na chave step com esse tipo de parâmetro só será serializado como uma ação composta se as etapas forem usadas no início ou no final das etapas do modelo. Um modelo usado nas chaves stage, deployment e job com esse tipo de parâmetro não são transformados em um fluxo de trabalho reutilizável e são serializados como um fluxo de trabalho autônomo.

Partes foram adaptadas do https://.com//gh-actions-importer/ de acordo com a licença MIT:

MIT License

Copyright (c) 2022 

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.