{"meta":{"title":"Migración de Jenkins a Acciones de GitHub","intro":"GitHub Actions y Jenkins tienen mucho en común, lo que hace que la migración a GitHub Actions sea relativamente sencilla.","product":"GitHub Actions","breadcrumbs":[{"href":"/es/actions","title":"GitHub Actions"},{"href":"/es/actions/tutorials","title":"Tutoriales"},{"href":"/es/actions/tutorials/migrate-to-github-actions","title":"Migrar a GitHub Actions"},{"href":"/es/actions/tutorials/migrate-to-github-actions/manual-migrations","title":"Migraciones manuales"},{"href":"/es/actions/tutorials/migrate-to-github-actions/manual-migrations/migrate-from-jenkins","title":"Migrar desde Jenkins"}],"documentType":"article"},"body":"# Migración de Jenkins a Acciones de GitHub\n\nGitHub Actions y Jenkins tienen mucho en común, lo que hace que la migración a GitHub Actions sea relativamente sencilla.\n\n## Introducción\n\nJenkins y GitHub Actions ambos le permiten crear flujos de trabajo que compilen, prueben, publiquen, publiquen e implementen código automáticamente. Jenkins y GitHub Actions comparten algunas similitudes en la configuración del flujo de trabajo:\n\n* Jenkins crea flujos de trabajo mediante *canalizaciones declarativas*, que son similares a los GitHub Actions archivos de flujo de trabajo.\n* Jenkins usa *fases* para ejecutar una colección de pasos, mientras que GitHub Actions usa trabajos para agrupar uno o varios pasos o comandos individuales.\n* Jenkins y GitHub Actions admite compilaciones basadas en contenedores. Para más información, consulta [Creación de una acción de contenedor de Docker](/es/actions/tutorials/use-containerized-services/create-a-docker-container-action).\n* Los pasos o tareas pueden reutilizarse y compartirse con la comunidad.\n\nPara más información, consulta [Descripción de Acciones de GitHub](/es/actions/get-started/understand-github-actions).\n\n## Diferencias clave\n\n* Jenkins tiene dos tipos de sintaxis para crear mapas: Mapa Declarativo y Mapa de Script.\n  GitHub Actions usa YAML para crear flujos de trabajo y archivos de configuración. Para más información, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/reference/workflows-and-actions/workflow-syntax).\n* Los despliegues de jenkins son típicamente auto-hospedados y los usuarios mantienen los servidores en sus propios centros de datos.\n  GitHub Actions ofrece un enfoque de nube híbrida hospedando sus propios ejecutores que puede usar para ejecutar trabajos, al tiempo que admite ejecutores autohospedados. Para más información, consulta [Ejecutores autohospedados](/es/actions/concepts/runners/self-hosted-runners).\n\n## Comparación de capacidades\n\n### Distribuir tus compilaciones\n\nJenkis te permite enviar compilaciones a un agente de compilación sencilla, o puedes distribuirlas a través de varios agentes. También puedes clasificar estos agentes de acuerdo con diversos atributos, tales como los tipos de sistema operativo.\n\nDel mismo modo, GitHub Actions puede enviar trabajos a ejecutores hospedados en GitHub o autoalojados, y puedes usar etiquetas para clasificar los ejecutores en función de distintos atributos. Para más información, consulta [Descripción de Acciones de GitHub](/es/actions/get-started/understand-github-actions#runners) y [Ejecutores autohospedados](/es/actions/concepts/runners/self-hosted-runners).\n\n### Utilizar secciones para organizar tuberías\n\nJenkins divide sus Pipelines Declarativos en varias secciones. Del mismo modo, GitHub Actions organiza sus flujos de trabajo en secciones independientes. La tabla siguiente compara las secciones de Jenkins con el flujo de trabajo GitHub Actions.\n\n| Directivas de Jenkins                                           | GitHub Actions                                                                                                                                                                                                             |\n| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`agent`](https://jenkins.io/doc/book/pipeline/syntax/#agent)   | [`jobs.<job_id>.runs-on`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idruns-on) <br> [`jobs.<job_id>.container`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idcontainer) |\n| [`post`](https://jenkins.io/doc/book/pipeline/syntax/#post)     | Ninguno                                                                                                                                                                                                                    |\n| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#stages) | [`jobs`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobs)                                                                                                                                                 |\n| [`steps`](https://jenkins.io/doc/book/pipeline/syntax/#steps)   | [`jobs.<job_id>.steps`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps)                                                                                                                       |\n\n## Directivas de Uso\n\nJenkins usa directivas para administrar *Canalizaciones declarativas*. Estas directivas definen las características de tu flujo de trabajo y la manera en que se ejecuta. En la tabla siguiente se muestra cómo estas directivas se asignan a conceptos dentro de GitHub Actions.\n\n| Directivas de Jenkins                                                                                                                                 | GitHub Actions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n| ----------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`environment`](https://jenkins.io/doc/book/pipeline/syntax/#environment)                                                                             | [`jobs.<job_id>.env`](/es/actions/reference/workflows-and-actions/workflow-syntax#env) <br> [`jobs.<job_id>.steps[*].env`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsenv)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |\n| [`options`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                                     | [`jobs.<job_id>.strategy`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategy) <br> [`jobs.<job_id>.strategy.fail-fast`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategyfail-fast) <br> [`jobs.<job_id>.timeout-minutes`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idtimeout-minutes)                                                                                                                                                                                                                                                                                                                       |\n| [`parameters`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                                  | [`inputs`](/es/actions/reference/workflows-and-actions/metadata-syntax#inputs) <br> [`outputs`](/es/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`](/es/actions/reference/workflows-and-actions/workflow-syntax#on) <br> [`on.<event_name>.types`](/es/actions/reference/workflows-and-actions/workflow-syntax#onevent_nametypes) <br> [<code>on.\\<push>.\\<branches\\|tags></code>](/es/actions/reference/workflows-and-actions/workflow-syntax#onpushbranchestagsbranches-ignoretags-ignore) <br> [<code>on.\\<pull\\_request>.\\<branches></code>](/es/actions/reference/workflows-and-actions/workflow-syntax#onpull_requestpull_request_targetbranchesbranches-ignore) <br> [<code>on.\\<push\\|pull\\_request>.paths</code>](/es/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`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idneeds)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| [Sintaxis cron de Jenkins](https://jenkins.io/doc/book/pipeline/syntax/#cron-syntax)                                                                  | [`on.schedule`](/es/actions/reference/workflows-and-actions/workflow-syntax#onschedule)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n| [`stage`](https://jenkins.io/doc/book/pipeline/syntax/#stage)                                                                                         | [`jobs.<job_id>`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_id) <br> [`jobs.<job_id>.name`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idname)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |\n| [`tools`](https://jenkins.io/doc/book/pipeline/syntax/#tools)                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |\n| [Especificaciones para GitHubejecutores hospedados](/es/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images) |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |\n| [`input`](https://jenkins.io/doc/book/pipeline/syntax/#input)                                                                                         | [`inputs`](/es/actions/reference/workflows-and-actions/metadata-syntax#inputs)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n| [`when`](https://jenkins.io/doc/book/pipeline/syntax/#when)                                                                                           | [`jobs.<job_id>.if`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n\n## Utilizar etapas secuenciales\n\n### Procesamiento paralelo de tareas\n\nJenkins puede ejecutar `stages` y `steps` en paralelo.\nGitHub Actions ejecuta trabajos en paralelo y también puede ejecutar pasos de forma simultánea dentro de un trabajo mediante sintaxis a nivel de paso. Para obtener más información, consulte [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsbackground).\n\n| Jenkins en Paralelo                                                 | GitHub Actions                                                                                                                      |\n| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |\n| [`parallel`](https://jenkins.io/doc/book/pipeline/syntax/#parallel) | [`jobs.<job_id>.strategy.max-parallel`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategymax-parallel) |\n\n### Matriz\n\nTanto GitHub Actions como Jenkins permiten utilizar una matriz para definir distintas combinaciones del sistema.\n\n| Jenkins                                                                  | GitHub Actions                                                                                                                                                                                      |\n| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| [`axis`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-axes)       | [`strategy/matrix`](/es/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations#about-matrix-strategies) <br> [`context`](/es/actions/reference/workflows-and-actions/contexts) |\n| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages)   | [`steps-context`](/es/actions/reference/workflows-and-actions/contexts#steps-context)                                                                                                               |\n| [`excludes`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages) | Ninguno                                                                                                                                                                                             |\n\n### Utilizar pasos para ejecutar tareas\n\nJenkins agrupa `steps` en `stages`. Cada uno de estos pasos puede ser un script, función, o comando, entre otros. Del mismo modo, GitHub Actions usa `jobs` para ejecutar 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`](/es/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps) |\n\n## Ejemplos de tareas comunes\n\n### Programación de una canalización para ejecutar con `cron`\n\n#### Canalización de Jenkins con `cron`\n\n```yaml\npipeline {\n  agent any\n  triggers {\n    cron('H/15 * * * 1-5')\n  }\n}\n```\n\n#### GitHub Actions flujo de trabajo con `cron`\n\n```yaml\non:\n  schedule:\n    - cron: '*/15 * * * 1-5'\n```\n\nPara más información sobre los eventos `schedule`y la sintaxis de cron aceptada, consulta [Eventos que desencadenan flujos de trabajo](/es/actions/reference/workflows-and-actions/events-that-trigger-workflows#schedule).\n\n### Configurar variables de entorno en una canalización\n\n#### Canalización de Jenkins con una variable de entorno\n\n```yaml\npipeline {\n  agent any\n  environment {\n    MAVEN_PATH = '/usr/local/maven'\n  }\n}\n```\n\n#### GitHub Actions flujo de trabajo con una variable de entorno\n\n```yaml\njobs:\n  maven-build:\n    env:\n      MAVEN_PATH: '/usr/local/maven'\n```\n\n### Compilar desde proyectos ascendentes\n\n#### Canalización de Jenkins que se compila a partir de un proyecto ascendente\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 flujo de trabajo que se genera a partir de un proyecto de origen\n\n```yaml\njobs:\n  job1:\n  job2:\n    needs: job1\n  job3:\n    needs: [job1, job2]\n```\n\n### Construir con múltiples sistemas operativos\n\n#### Canalización de Jenkins que se compila con varios sistemas operativos\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 flujo de trabajo que se compila con varios sistemas operativos\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```"}