{"meta":{"title":"Migrando do Jenkins para o GitHub Actions","intro":"GitHub Actions e Jenkins compartilham várias semelhanças, o que torna a migração para GitHub Actions relativamente simples.","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/manual-migrations","title":"Migrações manuais"},{"href":"/pt/actions/tutorials/migrate-to-github-actions/manual-migrations/migrate-from-jenkins","title":"Migrar do Jenkins"}],"documentType":"article"},"body":"# Migrando do Jenkins para o GitHub Actions\n\nGitHub Actions e Jenkins compartilham várias semelhanças, o que torna a migração para GitHub Actions relativamente simples.\n\n## Introdução\n\nO Jenkins e GitHub Actions ambos permitem criar fluxos de trabalho que criam, testam, publicam, liberam e implantam código automaticamente. Jenkins e GitHub Actions compartilham algumas semelhanças na configuração do fluxo de trabalho:\n\n* O Jenkins cria fluxos de trabalho usando *Pipelines Declarativos*, que são semelhantes aos GitHub Actions arquivos de fluxo de trabalho.\n* O Jenkins usa *estágios* para executar uma coleção de etapas, enquanto GitHub Actions usa trabalhos para agrupar uma ou mais etapas ou comandos individuais.\n* Jenkins e GitHub Actions oferecem suporte a compilações baseadas em contêineres. Para saber mais, confira [Criando uma ação de contêiner do Docker](/pt/actions/tutorials/use-containerized-services/create-a-docker-container-action).\n* É possível reutilizar e compartilhar novamente etapas ou tarefas com a comunidade.\n\nPara saber mais, confira [Noções básicas sobre GitHub Actions](/pt/actions/get-started/understand-github-actions).\n\n## Principais diferenças\n\n* O Jenkins tem dois tipos de sintaxe para a criação de pipelines: Declarative Pipeline e Scripted Pipeline.\n  GitHub Actions usa YAML para criar fluxos de trabalho e arquivos de configuração. Para saber mais, confira [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/actions/reference/workflows-and-actions/workflow-syntax).\n* As implementações do Jenkins são tipicamente auto-hospedadas, com usuários mantendo os servidores em seus próprios centros de dados.\n  GitHub Actions oferece uma abordagem de nuvem híbrida hospedando seus próprios corredores que você pode usar para executar trabalhos, ao mesmo tempo em que dá suporte a corredores auto-hospedados. Para saber mais, confira [Executores auto-hospedados](/pt/actions/concepts/runners/self-hosted-runners).\n\n## Comparar recursos\n\n### Distribuir suas criações\n\nO Jenkins permite que se envie criações para um único agente de criação, ou você pode distribuí-las entre vários agentes. Você também pode classificar esses agentes de acordo com vários atributos, como, por exemplo, tipos de sistema operacional.\n\nDa mesma forma, GitHub Actions pode enviar trabalhos para executores hospedados no GitHub ou auto-hospedados, e pode usar rótulos para classificar os executores de acordo com vários atributos. Para saber mais, confira [Noções básicas sobre GitHub Actions](/pt/actions/get-started/understand-github-actions#runners) e [Executores auto-hospedados](/pt/actions/concepts/runners/self-hosted-runners).\n\n### Usar seções para organizar pipelines\n\nO Jenkins divide seus Declarative Pipelines em múltiplas seções. Da mesma forma, GitHub Actions organiza seus fluxos de trabalho em seções separadas. A tabela a seguir compara as seções do Jenkins com o GitHub Actions fluxo de trabalho.\n\n| Diretivas do Jenkins                                            | GitHub Actions                                                                                                                                                                                                             |\n| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`agent`](https://jenkins.io/doc/book/pipeline/syntax/#agent)   | [`jobs.<job_id>.runs-on`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idruns-on) <br> [`jobs.<job_id>.container`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idcontainer) |\n| [`post`](https://jenkins.io/doc/book/pipeline/syntax/#post)     | Nenhum                                                                                                                                                                                                                     |\n| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#stages) | [`jobs`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobs)                                                                                                                                                 |\n| [`steps`](https://jenkins.io/doc/book/pipeline/syntax/#steps)   | [`jobs.<job_id>.steps`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps)                                                                                                                       |\n\n## Uso de diretivas\n\nO Jenkins usa diretivas para gerenciar os *Pipelines Declarativos*. Essas diretivas definem as características do seu fluxo de trabalho e como ele será executado. A tabela a seguir demonstra como essas diretivas correspondem a conceitos em GitHub Actions.\n\n| Diretivas do Jenkins                                                                                                                             | GitHub Actions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n| ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`environment`](https://jenkins.io/doc/book/pipeline/syntax/#environment)                                                                        | [`jobs.<job_id>.env`](/pt/actions/reference/workflows-and-actions/workflow-syntax#env) <br> [`jobs.<job_id>.steps[*].env`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsenv)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |\n| [`options`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                                | [`jobs.<job_id>.strategy`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategy) <br> [`jobs.<job_id>.strategy.fail-fast`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategyfail-fast) <br> [`jobs.<job_id>.timeout-minutes`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idtimeout-minutes)                                                                                                                                                                                                                                                                                                                       |\n| [`parameters`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                             | [`inputs`](/pt/actions/reference/workflows-and-actions/metadata-syntax#inputs) <br> [`outputs`](/pt/actions/reference/workflows-and-actions/metadata-syntax#outputs-for-docker-container-and-javascript-actions)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |\n| [`triggers`](https://jenkins.io/doc/book/pipeline/syntax/#triggers)                                                                              | [`on`](/pt/actions/reference/workflows-and-actions/workflow-syntax#on) <br> [`on.<event_name>.types`](/pt/actions/reference/workflows-and-actions/workflow-syntax#onevent_nametypes) <br> [<code>on.\\<push>.\\<branches\\|tags></code>](/pt/actions/reference/workflows-and-actions/workflow-syntax#onpushbranchestagsbranches-ignoretags-ignore) <br> [<code>on.\\<pull\\_request>.\\<branches></code>](/pt/actions/reference/workflows-and-actions/workflow-syntax#onpull_requestpull_request_targetbranchesbranches-ignore) <br> [<code>on.\\<push\\|pull\\_request>.paths</code>](/pt/actions/reference/workflows-and-actions/workflow-syntax#onpushpull_requestpull_request_targetpathspaths-ignore) |\n| [`triggers { upstreamprojects() }`](https://jenkins.io/doc/book/pipeline/syntax/#triggers)                                                       | [`jobs.<job_id>.needs`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idneeds)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| [Sintaxe cron do Jenkins](https://jenkins.io/doc/book/pipeline/syntax/#cron-syntax)                                                              | [`on.schedule`](/pt/actions/reference/workflows-and-actions/workflow-syntax#onschedule)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n| [`stage`](https://jenkins.io/doc/book/pipeline/syntax/#stage)                                                                                    | [`jobs.<job_id>`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_id) <br> [`jobs.<job_id>.name`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idname)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |\n| [`tools`](https://jenkins.io/doc/book/pipeline/syntax/#tools)                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |\n| [Especificações para GitHubrunners hospedados](/pt/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images) |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |\n| [`input`](https://jenkins.io/doc/book/pipeline/syntax/#input)                                                                                    | [`inputs`](/pt/actions/reference/workflows-and-actions/metadata-syntax#inputs)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n| [`when`](https://jenkins.io/doc/book/pipeline/syntax/#when)                                                                                      | [`jobs.<job_id>.if`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n\n## Usar estágios sequenciais\n\n### Processamento paralelo do trabalho\n\nJenkins pode executar o `stages` e `steps` em paralelo.\nGitHub Actions executa trabalhos em paralelo e também pode executar etapas simultaneamente em um trabalho usando a sintaxe de nível de etapa. Para obter mais informações, consulte [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsbackground).\n\n| Jenkins em paralelo                                                 | GitHub Actions                                                                                                                      |\n| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |\n| [`parallel`](https://jenkins.io/doc/book/pipeline/syntax/#parallel) | [`jobs.<job_id>.strategy.max-parallel`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategymax-parallel) |\n\n### Matriz\n\nTanto GitHub Actions quanto Jenkins permitem que você use uma matriz para definir várias combinações do sistema.\n\n| Jenkins                                                                  | GitHub Actions                                                                                                                                                                                      |\n| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`axis`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-axes)       | [`strategy/matrix`](/pt/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations#about-matrix-strategies) <br> [`context`](/pt/actions/reference/workflows-and-actions/contexts) |\n| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages)   | [`steps-context`](/pt/actions/reference/workflows-and-actions/contexts#steps-context)                                                                                                               |\n| [`excludes`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages) | Nenhum                                                                                                                                                                                              |\n\n### Usar passos para executar tarefas\n\nO Jenkins agrupa as `steps` em `stages`. Cada uma dessas etapas pode ser um script, função ou comando, entre outros. Da mesma forma, GitHub Actions usa `jobs` para executar grupos específicos de `steps`.\n\n| Jenkins                                                       | GitHub Actions                                                                                       |\n| ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |\n| [`steps`](https://jenkins.io/doc/book/pipeline/syntax/#steps) | [`jobs.<job_id>.steps`](/pt/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps) |\n\n## Exemplos de tarefas comuns\n\n### Como agendar um pipeline para ser executado com o `cron`\n\n#### Pipeline do Jenkins com `cron`\n\n```yaml\npipeline {\n  agent any\n  triggers {\n    cron('H/15 * * * 1-5')\n  }\n}\n```\n\n#### GitHub Actions fluxo de trabalho com `cron`\n\n```yaml\non:\n  schedule:\n    - cron: '*/15 * * * 1-5'\n```\n\nPara obter mais informações sobre eventos `schedule` e a sintaxe cron aceita, consulte [Eventos que disparam fluxos de trabalho](/pt/actions/reference/workflows-and-actions/events-that-trigger-workflows#schedule).\n\n### Configurar variáveis de ambiente em um pipeline\n\n#### Pipeline do Jenkins com uma variável de ambiente\n\n```yaml\npipeline {\n  agent any\n  environment {\n    MAVEN_PATH = '/usr/local/maven'\n  }\n}\n```\n\n#### GitHub Actions fluxo de trabalho com uma variável de ambiente\n\n```yaml\njobs:\n  maven-build:\n    env:\n      MAVEN_PATH: '/usr/local/maven'\n```\n\n### Criar projetos projetos de upstream\n\n#### Pipeline do Jenkins baseado em um projeto upstream\n\n```yaml\npipeline {\n  triggers {\n    upstream(\n      upstreamProjects: 'job1,job2',\n      threshold: hudson.model.Result.SUCCESS\n    )\n  }\n}\n```\n\n#### GitHub Actions fluxo de trabalho criado a partir de um projeto de origem\n\n```yaml\njobs:\n  job1:\n  job2:\n    needs: job1\n  job3:\n    needs: [job1, job2]\n```\n\n### Criar com vários sistemas operacionais\n\n#### Pipeline do Jenkins baseado em vários sistemas operacionais\n\n```yaml\npipeline {\n  agent none\n  stages {\n    stage('Run Tests') {\n      matrix {\n        axes {\n          axis {\n            name: 'PLATFORM'\n            values: 'macos', 'linux'\n          }\n        }\n        agent { label \"${PLATFORM}\" }\n        stages {\n          stage('test') {\n            tools { nodejs \"node-20\" }\n            steps {\n              dir(\"scripts/myapp\") {\n                sh(script: \"npm install -g bats\")\n                sh(script: \"bats tests\")\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}\n```\n\n#### GitHub Actions fluxo de trabalho criado com vários sistemas operacionais\n\n```yaml\nname: demo-workflow\non:\n  push:\njobs:\n  test:\n    runs-on: ${{ matrix.os }}\n    strategy:\n      fail-fast: false\n      matrix:\n        os: [macos-latest, ubuntu-latest]\n    steps:\n      - uses: actions/checkout@v6\n      - uses: actions/setup-node@v7\n        with:\n          node-version: 20\n      - run: npm install -g bats\n      - run: bats tests\n        working-directory: ./scripts/myapp\n```"}