Migrarse desde la IC/EC de GitLab a GitHub Actions

Introducción

Tanto la IC/EC de GitLab como las GitHub Actions te permiten crear flujos de trabajo que crean, prueban, publican, lanzan y despliegan código automáticamente. La IC/EC de GitLab y las GitHub Actions comparten algunas similitudes en la configuración de los flujos de trabajo:

• Los archivos de configuración de flujo de trabajo están escritas en YAML y se almacenan en el repositorio del código.
• Los flujos de trabajo incluyen uno o más jobs.
• Los jobs incluyen uno o más pasos o comandos individuales.
• Los jobs pueden ejecutarse ya sea en máquinas administradas o auto-hospedadas.

Hay unas cuantas diferencias, y esta guía te mostrará las diferencias importantes para que puedas migrar tu flujo de trabajo a GitHub Actions.

Trabajos

Los jobs en la IC/EC de GitLab son muy similares a aquellos en GitHub Actions. En ambos sistemas, los jobs tienen las siguientes características:

• Los jobs contienen una serie de pasos o scripts que se ejecutan secuencialmente.
• Los jobs pueden ejecutarse en máquinas o contenedores separados.
• Los jobs se ejecutan en paralelo predeterminadamente, pero pueden configurarse para ejecutarse en secuencia.

Puedes ejecutar un script o un comando de shell en un job. En CI/CD de GitLab, los pasos de script se especifican con la clave script. En GitHub Actions, todos los scripts se especifican con la clave run.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

job1:
  variables:
    GIT_CHECKOUT: "true"
  script:
    - echo "Run your script here"

jobs:
  job1:
    steps:
      - uses: actions/checkout@v2
      - run: echo "Run your script here"

Ejecutores

Los ejecutores son máquinas en donde se ejecutan los jobs. Tanto la IC/EC de GitLab como las GitHub Actions ofrecen variantes administradas y auto-hospedadas de los ejecutores. En CI/CD de GitLab, tags se usan para ejecutar trabajos en distintas plataformas, mientras que en GitHub Actions se realiza con la clave runs-on.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

windows_job:
  tags:
    - windows
  script:
    - echo Hello, %USERNAME%!

linux_job: etiquetas:
    - script de Linux:
    - eco "Hello, $USER!"

windows_job:
  runs-on: windows-latest
  steps:
    - run: echo Hello, %USERNAME%!

linux_job:
  runs-on: ubuntu-latest
  steps:
    - run: echo "Hello, $USER!"

Para obtener más información, consulta "Sintaxis de flujo de trabajo para GitHub Actions".

Imágenes de Docker

Tanto la IC/EC de GitLab como las GitHub Actions son compatibles con la ejecución de jobs en una imagen de Docker. En CI/CD de GitLab, las imágenes de Docker se definen con una clave image, mientras que en GitHub Actions se realiza con la clave container.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

my_job:
  image: node:10.16-jessie

jobs:
  my_job:
    container: node:10.16-jessie

Para obtener más información, consulta "Sintaxis de flujo de trabajo para GitHub Actions".

Sintaxis de condiciones y expresiones

En CI/CD de GitLab se usa rules para determinar si un trabajo se ejecutará para una condición específica. Las GitHub Actions utilizan la palabra clave if para prevenir que un trabajo se ejecute a menos que se cumpla una condición.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

deploy_prod:
  stage: deploy
  script:
    - echo "Deploy to production server"
  rules:
    - if: '$CI_COMMIT_BRANCH == "master"'

jobs:
  deploy_prod:
    if: contains( github.ref, 'master')
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploy to production server"

Para obtener más información, consulta "Expresiones".

Dependencias entre los Jobs

Tanto la IC/EC de GitLab como las GitHub Actions te permiten configurar dependencias para un job. En ambos sistemas, los trabajos se ejecutan en paralelo de manera predeterminada, pero las dependencias de éstos en las GitHub Actions se pueden especificar explícitamente con la clave needs. La CI/CD de GitLab también tiene un concepto de stages, en donde los trabajos de una etapa se ejecutan simultáneamente, pero la siguiente etapa comenzará cuando todos los trabajos de la etapa anterior se hayan completado. Puedes recrear este escenario en GitHub Actions con la clave needs.

A continuación encontrarás un ejemplo de la sintaxis para cada sistema. Los flujos de trabajo comienzan con dos trabajos denominados build_a y build_b ejecutándose en paralelo, y cuando se completan esos trabajos, se ejecuta otro trabajo denominado test_ab. Por último, cuando test_ab se complete, se ejecutará el trabajo deploy_ab.

stages:
  - build
  - test
  - deploy

build_a: fase: script de compilación:
    - eco "Este trabajo se ejecutará primero".

build_b: fase: script de compilación:
    - echo "Este trabajo se ejecutará primero, en paralelo con build_a".

test_ab: fase: script de prueba:
    - eco "Este trabajo se ejecutará después de que build_a y build_b hayan finalizado".

deploy_ab: fase: script de implementación:
    - eco "Este trabajo se ejecutará una vez que se haya completado test_ab".

jobs:
  build_a:
    runs-on: ubuntu-latest
    steps:
      - run: echo "This job will be run first."

  build_b:
    runs-on: ubuntu-latest
    steps:
      - run: echo "This job will be run first, in parallel with build_a"

  test_ab:
    runs-on: ubuntu-latest
    needs: [build_a,build_b]
    steps:
      - run: echo "This job will run after build_a and build_b have finished"

  deploy_ab:
    runs-on: ubuntu-latest
    needs: [test_ab]
    steps:
      - run: echo "This job will run after test_ab is complete"

Para obtener más información, consulta "Sintaxis de flujo de trabajo para GitHub Actions".

Programar flujos de trabajo

Tanto la IC/EC de GitLab como las GitHub Actions te permiten ejecutar flujos de trabajo en un intervalo específico. En la IC/EC de GitLab, las programaciones de mapa se configuran con la IU, mientras que en las GitHub Actions puedes activar un flujo de trabajo en un intervalo programado con la clave "on".

Para más información, vea "Eventos que desencadenan flujos de trabajo".

Variables y secretos

La IC/EC de GitLab y las GitHub Actions son compatibles con la configuración de variables de ambiente en el mapa o en el archivo de configuración de flujo de trabajo, y con la creación de secretos utilizando la IU de GitLab o de GitHub Enterprise Server.

Para obtener más información, consulta "Variables de entorno" y "Secretos cifrados".

Almacenamiento en memoria caché

La IC/EC de GitLab y las GitHub Actions proporcionan un método en el archivo de configuración para guardar los archivos de flujo de trabajo manualmente en el caché.

El almacenamiento en caché de GitHub Actions solo está disponible para los repositorios hospedados en GitHub.com o GitHub Enterprise Server 3.5 y versiones posteriores. Para más información, vea "Almacenamiento en caché de dependencias para acelerar los flujos de trabajo".

Artifacts

Tanto la IC/EC de GitLab como las GitHub Actions pueden cargar como artefactos los archivos y directorios que creen los jobs. En las GitHub Actions, los artefactos pueden utilizarse para persistir los datos a través de varios jobs.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

script:
artifacts:
  paths:
    - math-homework.txt

- name: Upload math result for job 1
  uses: actions/upload-artifact@v2
  with:
    name: homework
    path: math-homework.txt

Para obtener más información, consulta "Almacenamiento de datos de flujo de trabajo como artefactos".

Bases de datos y contenedores de servicios

Ambos sistemas te permiten incluir contenedores adicionales para bases de datos, almacenamiento en caché, u otras dependencias.

En CI/CD de GitLab, se especifica un contenedor para el trabajo con la clave image, mientras que en GitHub Actions se usa la clave container. En ambos sistemas, se especifican contenedores de servicio adicionales con la clave services.

Aquí se muestra un ejemplo de la sintaxis para cada sistema:

container-job:
  variables:
    POSTGRES_PASSWORD: postgres
    # The hostname used to communicate with the
    # PostgreSQL service container
    POSTGRES_HOST: postgres
    # The default PostgreSQL port
    POSTGRES_PORT: 5432
  image: node:10.18-jessie
  services:
    - postgres
  script:
    # Performs a clean installation of all dependencies
    # in the `package.json` file
    - npm ci
    # Runs a script that creates a PostgreSQL client,
    # populates the client with data, and retrieves data
    - node client.js
  tags:
    - docker

jobs:
  container-job:
    runs-on: ubuntu-latest
    container: node:10.18-jessie

    services:
      postgres:
        image: postgres
        env:
          POSTGRES_PASSWORD: postgres

    steps:
      - name: Check out repository code
        uses: actions/checkout@v2

      # Performs a clean installation of all dependencies
      # in the `package.json` file
      - name: Install dependencies
        run: npm ci

      - name: Connect to PostgreSQL
        # Runs a script that creates a PostgreSQL client,
        # populates the client with data, and retrieves data
        run: node client.js
        env:
          # The hostname used to communicate with the
          # PostgreSQL service container
          POSTGRES_HOST: postgres
          # The default PostgreSQL port
          POSTGRES_PORT: 5432

Para obtener más información, consulta "Acerca de los contenedores de servicios".