{"meta":{"title":"Migrando do Bamboo para o GitHub Actions Importer","intro":"Saiba como usar GitHub Actions Importer para automatizar a migração de seus pipelines do Bamboo para GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/pt/actions","title":"GitHub Actions"},{"href":"/pt/actions/tutorials","title":"Tutoriais"},{"href":"/pt/actions/tutorials/migrate-to-github-actions","title":"Migrar para o GitHub Actions"},{"href":"/pt/actions/tutorials/migrate-to-github-actions/automated-migrations","title":"Migrações automatizadas"},{"href":"/pt/actions/tutorials/migrate-to-github-actions/automated-migrations/bamboo-migration","title":"Migração do Bamboo"}],"documentType":"article"},"body":"# Migrando do Bamboo para o GitHub Actions Importer\n\nSaiba como usar GitHub Actions Importer para automatizar a migração de seus pipelines do Bamboo para GitHub Actions.\n\n## Sobre a migração do Bamboo usando o Importador do GitHub Actions\n\nAs instruções a seguir orientarão você sobre como configurar seu ambiente para usar GitHub Actions Importer e migrar os pipelines do Bamboo para GitHub Actions.\n\n### Pré-requisitos\n\n* Uma conta do Bamboo ou uma organização com projetos e pipelines que você deseja converter para fluxos de trabalho do GitHub Actions.\n* Versão Bamboo 7.1.1 ou superior.\n* Acesso para criar um Bamboo personal access token para sua conta ou organização.\n* Um ambiente em que seja possível executar contêineres baseados no Linux e instalar as ferramentas necessárias.\n * O Docker está [instalado](https://docs.docker.com/get-docker/) e em execução.\n\n * A [CLI do GitHub](https://cli.github.com) está instalada.\n > \\[!NOTE]\n > A CLI e o contêiner do GitHub Actions Importer não precisam ser instalados no mesmo servidor que a plataforma de CI.\n\n### Limitações\n\nHá algumas limitações ao migrar do Bamboo para GitHub Actions com GitHub Actions Importer:\n\n* GitHub Actions Importer depende da especificação YAML gerada pelo Bamboo Server para executar migrações. Quando o Bamboo não dá suporte à exportação de algo para YAML, as informações ausentes não são migradas.\n* Não há suporte para condições de gatilho. Quando o GitHub Actions Importer encontra um gatilho com uma condição, a condição é exibida como um comentário e o gatilho é transformado sem ele.\n* Os Planos do Bamboo com configurações personalizadas para armazenar artefatos não são transformados. Em vez disso, os artefatos são armazenados e recuperados usando as ações [`upload-artifact`](https://github.com/actions/upload-artifact) e [`download-artifact`](https://github.com/actions/download-artifact).\n* Planos desativados devem ser desabilitados manualmente na interface do GitHub. Para saber mais, confira [Desabilitar e habilitar um fluxo de trabalho](/pt/actions/how-tos/manage-workflow-runs/disable-and-enable-workflows).\n* Trabalhos desabilitados são transformados com uma condição `if: false` que impede a sua execução. Remova isso para reativar a tarefa.\n* As tarefas desabilitadas não são transformadas porque não estão incluídas no plano exportado ao usar a API do Bamboo.\n* O Bamboo fornece opções para limpar workspaces de builds após a conclusão de um build. Eles não são transformados porque supõe-se que executores hospedados no GitHub ou executores auto-hospedados efêmeros lidarão automaticamente com isso.\n* As opções de detecção de build pendente não são transformadas porque não há equivalente no GitHub Actions. A opção mais próxima é `timeout-minutes` em um trabalho, que pode ser usado para definir o número máximo de minutos para permitir que um trabalho seja executado. Para saber mais, confira [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idtimeout-minutes).\n* A rotulagem por correspondência de padrões não é transformada porque não há equivalente em GitHub Actions.\n* Todos os artefatos são transformados em um `actions/upload-artifact`, independentemente de serem `shared` ou não, para que possam ser baixados de qualquer trabalho no fluxo de trabalho.\n* As permissões não são transformadas porque não há equivalente adequado em GitHub Actions.\n* Se a versão do Bamboo estiver entre 7.1.1 e 8.1.1, as variáveis de projeto e plano não serão migradas.\n\n#### Tarefas manuais\n\nCertos constructos do Bamboo devem ser migrados manualmente. Eles incluem:\n\n* Variáveis mascaradas\n* Configurações de expiração do artefato\n\n## Instalando a extensão da GitHub Actions Importer CLI\n\n1. Instale a extensão da CLI do GitHub Actions Importer:\n\n ```bash copy\n gh extension install github/gh-actions-importer\n ```\n\n2. Verifique se a extensão foi instalada:\n\n ```bash\n $ gh actions-importer -h\n Options:\n -?, -h, --help Show help and usage information\n\n Commands:\n update Update to the latest version of GitHub Actions Importer.\n version Display the version of GitHub Actions Importer.\n configure Start an interactive prompt to configure credentials used to authenticate with your CI server(s).\n audit Plan your CI/CD migration by analyzing your current CI/CD footprint.\n forecast Forecast GitHub Actions usage from historical pipeline utilization.\n dry-run Convert a pipeline to a GitHub Actions workflow and output its yaml file.\n migrate Convert a pipeline to a GitHub Actions workflow and open a pull request with the changes.\n ```\n\n## Como configurar credenciais\n\nO `configure` comando da CLI é usado para definir as credenciais e as opções necessárias para GitHub Actions Importer trabalhar com Bamboo e GitHub.\n\n1. Criar um GitHubpersonal access token (classic). Para saber mais, confira [Gerenciar seus tokens de acesso pessoal](/pt/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic).\n\n O token precisa ter o escopo `workflow`.\n\n Depois de criar o token, copie-o e salve-o em um local seguro para uso posterior.\n\n2. Crie um personal access token do Bamboo. Para obter mais informações, consulte [Personal Access Tokens](https://confluence.atlassian.com/bamboo/personal-access-tokens-976779873.html) a documentação do Bamboo.\n\n Seu token deve ter as seguintes permissões, dependendo de quais recursos serão transformados.\n\n | Tipo de recurso | Visualizar | Exibir configuração | Editar |\n | :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |\n | Plano de build | | | |\n | Projeto de implantação | | | |\n | Ambiente de implantação | | | |\n\n Depois de criar o token, copie-o e salve-o em um local seguro para uso posterior.\n\n3. No seu terminal, execute o comando CLI GitHub Actions Importer`configure`:\n\n ```shell\n gh actions-importer configure\n ```\n\n O comando `configure` solicitará que você insira as seguintes informações:\n\n * Em \"Quais provedores de CI você está configurando?\", use as teclas de direção para selecionar `Bamboo`, pressione Espaço para fazer a seleção e pressione Enter.\n * Para \"Personal access token para GitHub\", insira o valor do personal access token (classic) que você criou anteriormente e pressione Enter.\n * Para \"URL base da instância do GitHub\", insira pressione Enter para aceitar o valor padrão (`https://github.com`).\n * Para \"Personal access token para Bamboo\", insira o valor do Bamboo personal access token que você criou anteriormente e pressione Enter.\n * Para \"URL base da instância do Bamboo\", insira a URL da instância do Bamboo Server ou do Bamboo Data Center e pressione Enter.\n\n Um exemplo do comando `configure` é mostrado abaixo:\n\n ```shell\n $ gh actions-importer configure\n ✔ Which CI providers are you configuring?: Bamboo\n Enter the following values (leave empty to omit):\n ✔ Personal access token for GitHub: ***************\n ✔ Base url of the GitHub instance: https://github.com\n ✔ Personal access token for Bamboo: ********************\n ✔ Base url of the Bamboo instance: https://bamboo.example.com\n Environment variables successfully updated.\n ```\n\n4. No terminal, execute o comando CLI GitHub Actions Importer`update` para se conectar a GitHub PackagesContainer registry e garantir que a imagem do contêiner esteja atualizada para a versão mais recente:\n\n ```shell\n gh actions-importer update\n ```\n\n A saída do comando será parecida com a mostrada abaixo:\n\n ```shell\n Updating ghcr.io/actions-importer/cli:latest...\n ghcr.io/actions-importer/cli:latest up-to-date\n ```\n\n## Executar uma auditoria do Bamboo\n\nVocê pode usar o comando `audit` para obter uma exibição de alto nível de todos os projetos em uma organização Bamboo.\n\nO comando `audit` executa as seguintes etapas:\n\n1. Busca todos os projetos definidos na organização Bamboo.\n2. Converte cada pipeline em seu fluxo de trabalho equivalente GitHub Actions .\n3. Gera um relatório que resume o quão completa e complexa de uma migração é possível com GitHub Actions Importer.\n\n### Como executar o comando de auditoria\n\nPara executar uma auditoria de uma instância do Bamboo, execute o seguinte comando no terminal:\n\n```shell\ngh actions-importer audit bamboo --output-dir tmp/audit\n```\n\n### Como inspecionar os resultados da auditoria\n\nOs 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.\n\nO resumo da auditoria contém as seções a seguir.\n\n#### Pipelines\n\nA seção \"Pipelines\" contém estatísticas gerais sobre a taxa de conversão realizada por GitHub Actions Importer.\n\nVeja abaixo alguns termos importantes que podem aparecer na seção \"Pipelines\":\n\n* **Pipelines bem-sucedidos** tiveram 100% dos componentes do pipeline e itens individuais convertidos automaticamente para seus equivalentes GitHub Actions.\n* **Pipelines parcialmente bem-sucedidos** tiveram todos os constructos de pipeline convertidos, no entanto, havia alguns itens individuais que não foram convertidos automaticamente em seu GitHub Actions equivalente.\n* **Pipelines sem suporte** são tipos de definição que não têm suporte GitHub Actions Importer.\n* Pipelines **com falha** apresentaram um erro fatal durante a conversão. Isso pode ocorrer por uma das seguintes razões:\n * O pipeline foi originalmente configurado incorretamente e era inválido.\n * GitHub Actions Importer encontrou um erro interno ao convertê-lo.\n * Houve uma resposta de rede malsucedida que tornou o pipeline inacessível, o que geralmente ocorre devido a credenciais inválidas.\n\n#### Etapas de compilação\n\nA seção \"Etapas de compilação\" contém uma visão geral das etapas de compilação individuais usadas em todos os pipelines e de quantas delas foram convertidas automaticamente por GitHub Actions Importer.\n\nA seguir estão alguns termos-chave que podem aparecer na seção \"Build steps\":\n\n* Uma etapa de compilação **conhecida** foi convertida automaticamente em uma ação equivalente.\n* Uma etapa de compilação **desconhecida** não foi convertida automaticamente em uma ação equivalente.\n* Uma etapa de compilação **sem suporte** é aquela que:\n * Fundamentalmente não suportado por GitHub Actions.\n * Configurado de uma maneira incompatível com GitHub Actions.\n* Uma **ação** é uma lista das ações que foram usadas nos fluxos de trabalho convertidos. Isso pode ser importante para:\n * Se você usar GitHub Enterprise Server, reunindo a lista de ações para sincronizar com sua instância.\n * Definir uma lista de permissões em nível organizacional para as ações utilizadas. Essa lista de ações é abrangente e inclui as ações que as equipes de segurança ou conformidade podem precisar analisar.\n\n#### Tarefas manuais\n\nA seção \"Tarefas manuais\" contém uma visão geral das tarefas que GitHub Actions Importer não podem ser concluídas automaticamente e que você deve concluir manualmente.\n\nVeja abaixo alguns termos importantes que podem aparecer na seção \"Tarefas manuais\":\n\n* Um **segredo** é um segredo no nível do repositório ou da organização que é usado nos pipelines convertidos. Esses segredos devem ser criados manualmente no GitHub Actions para que esses pipelines funcionem corretamente. Para saber mais, confira [Usar segredos em ações do GitHub](/pt/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets).\n* Um **executor auto-hospedado refere-se** a um rótulo de um executor que é referenciado em um pipeline convertido que não é um GitHubexecutor hospedado. Será necessário definir manualmente esses executores para que os pipelines funcionem de maneira correta.\n\n#### Arquivos\n\nA seção final do relatório de auditoria fornece um manifesto de todos os arquivos que foram gravados em disco durante a auditoria.\n\nCada arquivo de pipeline tem diversos arquivos incluídos na auditoria, incluindo:\n\n* O pipeline original como ele foi definido em GitHub.\n* Todas as respostas de rede usadas para converter o pipeline.\n* O arquivo de fluxo de trabalho convertido.\n* Rastros de pilha que podem ser usados para solucionar problemas em uma falha na conversão de um pipeline.\n\nAlé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.\n\n## Previsão de uso\n\nVocê pode usar o comando `forecast` para prever o uso potencial do GitHub Actions calculando as métricas direto de execuções de pipeline concluídas na instância do Bamboo.\n\n### Como executar o comando de previsão\n\nPara executar uma previsão de uso potencial GitHub Actions , execute o comando a seguir em seu terminal. Por padrão, GitHub Actions Importer inclui os sete dias anteriores no relatório de previsão.\n\n```shell\ngh actions-importer forecast bamboo --output-dir tmp/forecast_reports\n```\n\n### Previsão de um projeto\n\nPara limitar a previsão aos ambientes de planos e implantações associados a um projeto, você pode usar a opção `--project`, em que o valor é definido como uma chave do projeto de build.\n\nPor exemplo:\n\n```shell\ngh actions-importer forecast bamboo --project PAN --output-dir tmp/forecast_reports\n```\n\n### Como inspecionar o relatório de previsão\n\nO arquivo `forecast_report.md` no diretório de saída especificado contém os resultados da previsão.\n\nVeja abaixo alguns termos importantes que podem aparecer no relatório de previsão:\n\n* A **contagem de trabalhos** é o número total de trabalhos concluídos.\n* A **contagem de pipelines** é o número de pipelines exclusivos usados.\n* O **tempo de execução** descreve a quantidade de tempo que um executor gastou na execução de uma tarefa. Essa métrica pode ser usada para ajudar a planejar o custo dos GitHubexecutores hospedados.\n * Essa métrica está correlacionada ao quanto você deve esperar gastar no GitHub Actions. Isso pode variar de acordo com o hardware usado para esses minutos. Você pode usar a [GitHub Actions calculadora de preços](https://github.com/pricing/calculator) para estimar os custos.\n* ```\n As métricas de **tempo de espera** descrevem o tempo gasto por um trabalho aguardando um executor ficar disponível para executá-lo.\n ```\n* As métricas de **trabalhos simultâneos** descrevem a quantidade de trabalhos em execução a qualquer momento. Essa métrica pode ser usada para\n\n## Executar uma migração de simulação de um pipeline do Bamboo\n\nVocê pode usar o `dry-run` comando para converter um pipeline do Bamboo em um fluxo de trabalho equivalente GitHub 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.\n\n### Executar uma migração simulada para um plano de build\n\nPara executar uma simulação da migração do plano de build do Bamboo para o GitHub Actions, execute o seguinte comando no terminal, substituindo `:my_plan_slug` pelo projeto do plano e pela chave de plano no formato `-` (por exemplo: `PAN-SCRIP`).\n\n```shell\ngh actions-importer dry-run bamboo build --plan-slug :my_plan_slug --output-dir tmp/dry-run\n```\n\n### Executar uma migração simulada para um projeto de implantação\n\nPara executar uma simulação da migração do seu projeto de implantação do Bamboo para GitHub Actions, execute o seguinte comando no terminal, substituindo `:my_deployment_project_id` pela ID do projeto de implantação que você está convertendo.\n\n```shell\ngh actions-importer dry-run bamboo deployment --deployment-project-id :my_deployment_project_id --output-dir tmp/dry-run\n```\n\nVocê pode ver os logs da simulação e os arquivos de fluxo de trabalho convertidos no diretório de saída especificado.\n\nSe houver algo que GitHub Actions Importer não foi capaz de converter automaticamente, como etapas de build desconhecidas ou um pipeline parcialmente bem-sucedido, talvez você queira criar transformadores personalizados para personalizar ainda mais o processo de conversão. Para saber mais, confira [Estendendo o Importador do GitHub Actions com transformadores personalizados](/pt/actions/reference/github-actions-importer/custom-transformers).\n\n## Executar uma migração de produção de um pipeline do Bamboo\n\nVocê pode usar o `migrate` comando para converter um pipeline do Bamboo e abrir uma solicitação de pull com o fluxo de trabalho equivalente GitHub Actions .\n\n### Como executar o comando de migração para um plano de build\n\nPara migrar um plano de build do Bamboo para GitHub Actions, execute o seguinte comando no terminal, substituindo o valor de `target-url` pela URL do seu repositório GitHub e o valor de `:my_plan_slug` pelo projeto e pela chave do plano no formato `-`.\n\n```shell\ngh actions-importer migrate bamboo build --plan-slug :my_plan_slug --target-url :target_url --output-dir tmp/migrate\n```\n\nA saída do comando inclui a URL para a solicitação de pull que adiciona o fluxo de trabalho convertido ao seu repositório. Um exemplo de uma saída bem-sucedida é semelhante ao seguinte:\n\n```shell\n$ gh actions-importer migrate bamboo build --plan-slug :PROJECTKEY-PLANKEY --target-url https://github.com/octo-org/octo-repo --output-dir tmp/migrate\n[2022-08-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20220916-014033.log'\n[2022-08-20 22:08:20] Pull request: 'https://github.com/octo-org/octo-repo/pull/1'\n```\n\n### Executar o comando de migração para um projeto de implantação\n\nPara migrar um projeto de implantação do Bamboo para GitHub Actions, execute o seguinte comando no terminal, substituindo o valor de `target-url` pela URL do seu repositório GitHub e `:my_deployment_project_id` pelo ID do projeto de implantação que você está convertendo.\n\n```shell\ngh actions-importer migrate bamboo deployment --deployment-project-id :my_deployment_project_id --target-url :target_url --output-dir tmp/migrate\n```\n\nA saída do comando inclui a URL para a solicitação de pull que adiciona o fluxo de trabalho convertido ao seu repositório. Um exemplo de uma saída bem-sucedida é semelhante ao seguinte:\n\n```shell\n$ gh actions-importer migrate bamboo deployment --deployment-project-id 123 --target-url https://github.com/octo-org/octo-repo --output-dir tmp/migrate\n[2023-04-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20230420-014033.log'\n[2023-04-20 22:08:20] Pull request: 'https://github.com/octo-org/octo-repo/pull/1'\n```\n\n### Como inspecionar a solicitação de pull\n\nA 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.\n\nAlguns elementos importantes da solicitação de pull incluem:\n\n* 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 GitHub Actions. Por exemplo, esta seção pode solicitar a criação dos segredos usados nos fluxos de trabalho.\n* 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 GitHub.\n\nQuando terminar de inspecionar a pull request, você poderá mesclá-la para adicionar o fluxo de trabalho ao repositório do GitHub.\n\n## Referência\n\nEsta seção contém informações de referência sobre variáveis de ambiente, argumentos opcionais e sintaxe com suporte ao usar GitHub Actions Importer para migrar do Bamboo.\n\n### Usando variáveis de ambiente\n\nO GitHub 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](#configuring-credentials).\n\nGitHub Actions Importer usa as seguintes variáveis de ambiente para se conectar à instância do Bamboo:\n\n* `GITHUB_ACCESS_TOKEN`: o personal access token (classic) usado para criar pull requests com um fluxo de trabalho convertido (requer os escopos de `repo` e `workflow`).\n* `GITHUB_INSTANCE_URL`: a URL para a instância de destino GitHub (por exemplo, `https://github.com`).\n* `BAMBOO_ACCESS_TOKEN`: o personal access token do Bamboo usado para autenticar com a instância do Bamboo.\n* `BAMBOO_INSTANCE_URL`: a URL da instância do Bamboo (por exemplo, `https://bamboo.example.com`).\n\nEssas variáveis de ambiente podem ser especificadas em um `.env.local` arquivo que é carregado pelo GitHub Actions Importer quando ele é executado.\n\n### Argumentos opcionais\n\nHá argumentos opcionais que você pode usar com os subcomandos do GitHub Actions Importer para personalizar sua migração.\n\n#### `--source-file-path`\n\nUse o argumento `--source-file-path` com os subcomandos `dry-run` ou `migrate`.\n\nPor padrão, GitHub Actions Importer busca o conteúdo do pipeline da instância do Bamboo. O argumento `--source-file-path` informa ao GitHub Actions Importer que use o caminho do arquivo de origem especificado.\n\nPor exemplo:\n\n```shell\ngh actions-importer dry-run bamboo build --plan-slug IN-COM -o tmp/bamboo --source-file-path ./path/to/my/bamboo/file.yml\n```\n\n#### `--config-file-path`\n\nUse o argumento `--config-file-path` com os subcomandos `audit`, `dry-run` e `migrate`.\n\nPor padrão, GitHub Actions Importer busca o conteúdo do pipeline da instância do Bamboo. O argumento `--config-file-path` instrui GitHub Actions Importer a usar os arquivos de origem especificados.\n\n##### Exemplo de auditoria\n\nNeste exemplo, GitHub Actions Importer usa o arquivo de configuração YAML especificado para executar uma auditoria.\n\n```bash\ngh actions-importer audit bamboo -o tmp/bamboo --config-file-path \"./path/to/my/bamboo/config.yml\"\n```\n\nPara auditar uma instância do Bamboo usando um arquivo de configuração, o arquivo de configuração precisa estar no seguinte formato e cada `repository_slug` precisa ser exclusivo:\n\n```yaml\nsource_files:\n - repository_slug: IN/COM\n path: path/to/one/source/file.yml\n - repository_slug: IN/JOB\n path: path/to/another/source/file.yml\n```\n\n##### Exemplo de simulação a seco\n\nNeste exemplo, GitHub Actions Importer usa o arquivo de configuração YAML especificado como o arquivo de origem para executar uma execução seca.\n\nO campo de dados dinâmico do repositório é criado usando a opção `--plan-slug` . O caminho do arquivo de origem é localizado e extraído do arquivo especificado.\n\n```bash\ngh actions-importer dry-run bamboo build --plan-slug IN-COM -o tmp/bamboo --config-file-path \"./path/to/my/bamboo/config.yml\"\n```\n\n### Sintaxe com suporte para pipelines do Bamboo\n\nA tabela a seguir mostra o tipo de propriedades que GitHub Actions Importer atualmente é capaz de converter.\n\n| Bamboo | GitHub Actions | Status |\n| :---------------------------------- | :---------------------------------------------- | ------------------: |\n| `environments` | `jobs` | Com suporte |\n| `environments.` | `jobs.` | Com suporte |\n| `.artifacts` | `jobs..steps.actions/upload-artifact` | Com suporte |\n| `.artifact-subscriptions` | `jobs..steps.actions/download-artifact` | Com suporte |\n| `.docker` | `jobs..container` | Com suporte |\n| `.final-tasks` | `jobs..steps.if` | Com suporte |\n| `.requirements` | `jobs..runs-on` | Com suporte |\n| `.tasks` | `jobs..steps` | Com suporte |\n| `.variables` | `jobs..env` | Com suporte |\n| `stages` | `jobs..needs` | Com suporte |\n| `stages..final` | `jobs..if` | Com suporte |\n| `stages..jobs` | `jobs` | Com suporte |\n| `stages..jobs.` | `jobs.` | Com suporte |\n| `stages..manual` | `jobs..environment` | Com suporte |\n| `triggers` | `on` | Com suporte |\n| `dependencies` | `jobs..steps.` | Com suporte parcial |\n| `branches` | Não aplicável | Sem suporte |\n| `deployment.deployment-permissions` | Não aplicável | Sem suporte |\n| `environment-permissions` | Não aplicável | Sem suporte |\n| `notifications` | Não aplicável | Sem suporte |\n| `plan-permissions` | Não aplicável | Sem suporte |\n| `release-naming` | Não aplicável | Sem suporte |\n| `repositories` | Não aplicável | Sem suporte |\n\nPara obter mais informações sobre o conceito do Bamboo e os mapeamentos de plug-in com suporte, confira o repositório [`github/gh-actions-importer`](https://github.com/github/gh-actions-importer/blob/main/docs/bamboo/index.md).\n\n### Mapeamento de variáveis de ambiente\n\nGitHub Actions Importer usa o mapeamento na tabela abaixo para converter variáveis de ambiente padrão do Bamboo para os equivalentes mais próximos em GitHub Actions.\n\n| Bamboo | GitHub Actions |\n| :----------------------------------------------- | :------------------------------------------------------------------------------------ |\n| `bamboo.agentId` | `${{ github.runner_name }}` |\n| `bamboo.agentWorkingDirectory` | `${{ github.workspace }}` |\n| `bamboo.buildKey` | `${{ github.workflow }}-${{ github.job }}` |\n| `bamboo.buildNumber` | `${{ github.run_id }}` |\n| `bamboo.buildPlanName` | `${{ github.repository }}-${{ github.workflow }}-${{ github.job }` |\n| `bamboo.buildResultKey` | `${{ github.workflow }}-${{ github.job }}-${{ github.run_id }}` |\n| `bamboo.buildResultsUrl` | `${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}` |\n| `bamboo.build.working.directory` | `${{ github.workspace }}` |\n| `bamboo.deploy.project` | `${{ github.repository }}` |\n| `bamboo.ManualBuildTriggerReason.userName` | `${{ github.actor }}` |\n| `bamboo.planKey` | `${{ github.workflow }}` |\n| `bamboo.planName` | `${{ github.repository }}-${{ github.workflow }}` |\n| `bamboo.planRepository.branchDisplayName` | `${{ github.ref }}` |\n| `bamboo.planRepository..branch` | `${{ github.ref }}` |\n| `bamboo.planRepository..branchName` | `${{ github.ref }}` |\n| `bamboo.planRepository..name` | `${{ github.repository }}` |\n| `bamboo.planRepository..repositoryUrl` | `${{ github.server }}/${{ github.repository }}` |\n| `bamboo.planRepository..revision` | `${{ github.sha }}` |\n| `bamboo.planRepository..username` | `${{ github.actor}}` |\n| `bamboo.repository.branch.name` | `${{ github.ref }}` |\n| `bamboo.repository.git.branch` | `${{ github.ref }}` |\n| `bamboo.repository.git.repositoryUrl` | `${{ github.server }}/${{ github.repository }}` |\n| `bamboo.repository.pr.key` | `${{ github.event.pull_request.number }}` |\n| `bamboo.repository.pr.sourceBranch` | `${{ github.event.pull_request.head.ref }}` |\n| `bamboo.repository.pr.targetBranch` | `${{ github.event.pull_request.base.ref }}` |\n| `bamboo.resultsUrl` | `${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}` |\n| `bamboo.shortJobKey` | `${{ github.job }}` |\n| `bamboo.shortJobName` | `${{ github.job }}` |\n| `bamboo.shortPlanKey` | `${{ github.workflow }}` |\n| `bamboo.shortPlanName` | `${{ github.workflow }}` |\n\n> \\[!NOTE]\n> Variáveis desconhecidas são transformadas `${{ env. }}` e devem ser substituídas ou adicionadas `env` para a operação adequada. Por exemplo, `${bamboo.jira.baseUrl}` se tornará `${{ env.jira_baseUrl }}`.\n\n### Variáveis do sistema\n\nAs variáveis do sistema usadas em tarefas são transformadas na variável de shell de bash equivalente e são consideradas disponíveis. Por exemplo, `${system.}` será transformado em `$variable_name`. Recomendamos que você verifique isso para garantir a operação adequada do fluxo de trabalho.\n\n## Aviso legal\n\nPartes foram adaptadas do de acordo com a licença MIT:\n\n```text\nMIT License\n\nCopyright (c) 2022 GitHub\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n```"}