¿Cómo puedo usar las Acciones de GitHub para crear flujos de trabajo para CI?

Recuerde que el objetivo es automatizar el proceso de compilación y publicación de código para que las características se actualicen cada vez que un desarrollador agregue un cambio a la base de código.

Para implementar este proceso, aprenderá a:

• Cree un flujo de trabajo a partir de una plantilla.
• Evite la duplicación mediante flujos de trabajo reutilizables.
• Prueba con varios destinos.
• Separe los trabajos de compilación y prueba.

Creación de un flujo de trabajo a partir de una plantilla

Para crear un flujo de trabajo, es habitual empezar por usar una plantilla. Una plantilla tiene trabajos y pasos comunes preconfigurados para el tipo específico de automatización que está implementando. Si no está familiarizado con flujos de trabajo, trabajos y pasos, consulte el módulo Automatización de tareas de desarrollo mediante Acciones de GitHub .

En la página principal del repositorio de GitHub, seleccione Acciones y, a continuación, seleccione Nuevo flujo de trabajo.

En la página Elegir un flujo de trabajo , puede elegir entre muchos tipos de plantillas. Un ejemplo es la plantilla de Node.js. La plantilla deNode.js instala Node.js y todas las dependencias, compila el código fuente y ejecuta pruebas para distintas versiones de Node.js. Otro ejemplo es la plantilla de paquete de Python , que instala Python y sus dependencias, y luego ejecuta pruebas, incluido lint, en varias versiones de Python.

Para comenzar con la plantilla de flujo de trabajo de Node.js, en el cuadro de búsqueda, escriba Node.js.

En los resultados de la búsqueda, en el panelNode.js , seleccione Configurar.

Se crea un node.js.yml archivo para el proyecto a partir de la plantilla:

name: Node.js CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14.x, 16.x, 18.x]

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test

Como se observa en el atributo on, este flujo de trabajo de ejemplo se ejecuta en respuesta a una inserción al repositorio o cuando se crea una solicitud de incorporación de cambios contra la rama principal.

Este flujo de trabajo ejecuta un trabajo, indicado por el job atributo .

El runs-on atributo especifica que, para el sistema operativo, el flujo de trabajo se ejecuta en ubuntu-latest. El node-version atributo especifica que hay tres compilaciones, una para Node.js versión 14.x, 16.x y 18.x. El matrix atributo se describe en profundidad más adelante en el módulo.

En el atributo jobs, los pasos utilizan la acción de GitHub Actions actions/checkout@v3 para obtener el código del repositorio a una máquina virtual (VM) y actions/setup-node@v3 para configurar la versión correcta de Node.js. Especifique que desea probar tres versiones de Node.js mediante el ${{ matrix.node-version }} atributo . Este atributo hace referencia a la matriz que definió anteriormente. El cache atributo especifica un administrador de paquetes para el almacenamiento en caché en el directorio predeterminado.

La última parte de este paso ejecuta comandos que usan los proyectos Node.js. El npm ci comando instala las dependencias desde el package-lock.json archivo. npm run build --if-present ejecuta un script de compilación si existe. npm test ejecuta el marco de pruebas. Esta plantilla incluye los pasos de compilación y prueba en el mismo trabajo.

Para más información sobre npm, consulte la documentación de npm:

• instalación de npm
• Ejecución de npm
• Prueba de npm

Un equipo de desarrolladores puede beneficiarse del uso de flujos de trabajo reutilizables para simplificar y estandarizar los pasos de automatización repetidos. Mediante el uso de flujos de trabajo reutilizables, puede reducir la redundancia, mejorar el mantenimiento y garantizar la coherencia en las canalizaciones de integración continua o implementación continua (CI/CD).

Evitar la duplicación mediante flujos de trabajo reutilizables

A medida que los equipos escalan y crecen los proyectos, es habitual ver los mismos pasos repetidos en varios archivos de flujo de trabajo. Estos pasos pueden incluir la descarga de código, la instalación de dependencias, las pruebas y la implementación. Este tipo de duplicación no solo desordena la base de código, sino que también aumenta el tiempo de mantenimiento cuando se requieren cambios en el código. Los flujos de trabajo reutilizables resuelven este problema al permitirle definir la lógica de automatización una vez y, a continuación, llamar a la lógica desde otros flujos de trabajo.

Los flujos de trabajo reutilizables son flujos de trabajo de Acciones de GitHub especiales a los que pueden llamar otros flujos de trabajo, de forma similar a las funciones de programación. Los crea para compartir lógica repetida, como pasos de compilación, procedimientos de prueba o estrategias de implementación. Después de crear un flujo de trabajo reutilizable, puede hacer referencia a él desde cualquier otro flujo de trabajo del mismo repositorio o incluso en repositorios diferentes.

¿Por qué usar flujos de trabajo reutilizables?

Estas son las ventajas de usar flujos de trabajo reutilizables:

• Consistencia. Teams puede seguir los mismos estándares de automatización en todos los proyectos.
• Eficacia. En lugar de copiar y pegar pasos, solo tiene que apuntar a un flujo de trabajo reutilizable.
• Actualizaciones más sencillas. Cuando un proceso cambia, por ejemplo, agregando un paso de prueba, actualícelo en una ubicación. A continuación, todos los flujos de trabajo que usan la ventaja del flujo de trabajo automáticamente.
• Escalabilidad. Los flujos de trabajo reutilizables son ideales para equipos de plataforma o DevOps que administran varios servicios.

A continuación, explore cómo usar flujos de trabajo reutilizables para mejorar los proyectos.

Implementación de flujos de trabajo reutilizables

Para usar flujos de trabajo reutilizables:

1. En la carpeta del repositorio, cree un flujo de trabajo reutilizable. El archivo incluye los pasos de automatización que desea compartir, como los pasos comunes implicados en las pruebas, la compilación y la implementación.
2. Habilite explícitamente un flujo de trabajo para que sea reutilizable configurándolo con el workflow_call evento .
3. En los flujos de trabajo principales (flujos de trabajo del autor de la llamada), haga referencia a este archivo reutilizable y proporcione las entradas o secretos necesarios.

Para ilustrar las ventajas de los flujos de trabajo reutilizables, considere el siguiente escenario real.

Ejemplo

Imagine que su organización tiene 10 microservicios. Los 10 microservicios necesitan los mismos pasos para:

• Ejecución de pruebas
• Código de lint
• Implementación en un entorno específico

Sin flujos de trabajo reutilizables, cada repositorio termina duplicando la misma lógica entre varios archivos de flujo de trabajo, lo que conduce a pasos repetidos y mantenimiento más difícil.

Si usa flujos de trabajo reutilizables:

• El proceso se define una vez en un archivo central (por ejemplo, en ci-standard.yml).
• Llame a este archivo desde el propio flujo de trabajo de cada microservicio, pasando variables como el entorno o el nombre de la aplicación.

Si se agrega un nuevo paso de seguridad o herramienta, como buscar vulnerabilidades, solo se agrega una vez en el flujo de trabajo reutilizable. Los 10 microservicios comienzan a usar inmediatamente el proceso actualizado. No tiene que modificar los 10 microservicios.

Al comprender cómo funcionan los flujos de trabajo reutilizables y sus ventajas, puede adoptar procedimientos recomendados para maximizar su eficacia y garantizar una integración sin problemas con las canalizaciones de CI/CD.

procedimientos recomendados

• Centralice los flujos de trabajo reutilizables en un repositorio si planea compartirlos entre equipos.
• Use ramas o etiquetas para crear versiones de los flujos de trabajo (por ejemplo, use @v1), por lo que puede revertir fácilmente los cambios si es necesario.
• Documente de manera clara los datos y los secretos. Los flujos de trabajo reutilizables suelen depender de entradas y secretos. Los equipos deben saber qué información usar.
• Si necesita reutilizar solo unos pocos pasos, combine flujos de trabajo reutilizables con acciones compuestas en lugar de crear un flujo de trabajo completo.

Los flujos de trabajo reutilizables son una manera eficaz de aplicar la coherencia, reducir la duplicación y escalar los procedimientos de DevOps en cualquier equipo de ingeniería. Tanto si está administrando un único repositorio, microservicios o bibliotecas de código abierto, los flujos de trabajo reutilizables pueden simplificar la automatización, por lo que su CI/CD es más rápido, más limpio y fácil de administrar.

Personalización de plantillas de flujo de trabajo

Al principio de este módulo, consideraste un escenario en el que debes configurar CI para tu equipo de desarrolladores. La plantilla de Node.js es un buen comienzo, pero quieres personalizarla para adaptarla mejor a los requisitos de tu equipo. Quiere tener como destino diferentes versiones de Node.js y sistemas operativos diferentes. También quieres que los pasos de compilación y prueba sean tareas independientes.

Este es un ejemplo de un flujo de trabajo personalizado:

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest]
    node-version: [16.x, 18.x]

En este ejemplo, configurará una matriz de compilación para realizar pruebas en varios sistemas operativos y versiones de lenguaje. Esta matriz genera cuatro compilaciones, una para cada sistema operativo emparejada con cada versión de Node.js.

Cuatro compilaciones y sus pruebas producen una gran cantidad de datos de registro. Es posible que sea difícil ordenarlo todo. En el ejemplo siguiente, se mueve el paso de prueba a un trabajo de prueba dedicado. Este trabajo realiza pruebas con varios destinos. Separar los pasos de compilación y prueba facilita el trabajo con los datos de registro.

test:
  runs-on: ${{ matrix.os }}
  strategy:
    matrix:
      os: [ubuntu-latest, windows-latest]
      node-version: [16.x, 18.x]
  steps:
  - uses: actions/checkout@v3
  - name: Use Node.js ${{ matrix.node-version }}
    uses: actions/setup-node@v3
    with:
      node-version: ${{ matrix.node-version }}
  - name: npm install, and test
    run: |
      npm install
      npm test
    env:
      CI: true