LabEx
EntrarÚnete

Compilaciones de Matriz en GitHub Actions

GitBeginner
Practicar Ahora

Introducción

Al desarrollar software, es crucial asegurar que su código funcione correctamente en diferentes entornos. Por ejemplo, una librería de Node.js debe ser probada en múltiples versiones de Node.js (ej. v18, v20, v22).

En lugar de crear trabajos separados para cada versión, GitHub Actions proporciona una Estrategia de Matriz (Matrix Strategy). Esto le permite definir un conjunto de variables, y GitHub Actions creará automáticamente un trabajo para cada combinación de estas variables.

En este laboratorio, actualizará su flujo de trabajo para ejecutar sus pruebas en paralelo a través de tres versiones diferentes de Node.js.

Este laboratorio se basa en el repositorio que creó en los laboratorios anteriores. Trabajará con el repositorio github-actions-demo.

Modificar el flujo de trabajo para incluir la matriz de estrategia

La palabra clave strategy se utiliza para configurar la matriz de compilación (build matrix). Definiremos una matriz con una única clave node-version.

  1. En la página de tu repositorio de GitHub para github-actions-demo, haz clic en el botón verde Code.
  2. Asegúrate de que la pestaña HTTPS esté seleccionada y copia la URL. Debería verse como https://github.com/your-username/github-actions-demo.git.
  3. Abre la terminal en el entorno LabEx. La ruta predeterminada es ~/project.
  4. Usa el comando git clone para descargar el repositorio. Reemplaza your-username con tu nombre de usuario real de GitHub.
cd ~/project
git clone https://github.com/your-username/github-actions-demo.git

Salida de Ejemplo:

Cloning into 'github-actions-demo'...
remote: Enumerating objects: X, done.
remote: Counting objects: 100% (X/X), done.
remote: Total X (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (X/X), done.
  1. Navega dentro del repositorio clonado:
cd ~/project/github-actions-demo

  1. Crea un nuevo archivo de flujo de trabajo (workflow) .github/workflows/matrix-build.yml usando el editor WebIDE. Puedes encontrar el archivo en el explorador de archivos a la izquierda, bajo project/github-actions-demo/.github/workflows/.

  2. Comienza creando la estructura básica del flujo de trabajo. Añade el nombre del flujo de trabajo y el disparador (trigger):

name: Matrix Build

on: [push]
  1. Ahora añade la sección de trabajos (jobs) con una estructura básica de trabajo de compilación:
jobs:
  build:
    runs-on: ubuntu-latest
  1. Añade la estrategia de matriz. Esta es la parte clave que permite ejecutar el trabajo con múltiples versiones de Node.js:
strategy:
  matrix:
    node-version: [18, 20, 22]

Esto define una variable de matriz node-version con tres valores. GitHub Actions creará un trabajo separado para cada valor.

  1. Añade la sección de pasos (steps). Primero, añade el paso de checkout:
steps:
  - uses: actions/checkout@v4
  1. Añade el paso de configuración de Node.js. Observa cómo usamos ${{ matrix.node-version }} para hacer referencia al valor actual de la matriz:
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}
  1. Añade el paso para instalar dependencias:
- name: Install dependencies
  run: npm install
  1. Añade el paso de compilación que crea el directorio de artefactos:
- name: Build project
  run: |
    mkdir dist
    echo "This is the build artifact" > dist/build.txt
  1. Añade el paso de prueba:
- name: Run tests
  run: npm test
  1. Finalmente, añade el paso de carga de artefactos (upload artifact). Observa cómo el nombre del artefacto incluye la versión de la matriz para hacer cada artefacto único:
- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist

Tu archivo completo debería verse ahora así:

name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Explicación

  • strategy: Define la estrategia de compilación.
  • matrix: Define las variables de la matriz.
  • node-version: Este es un nombre de variable que elegimos. Le asignamos un array de valores [18, 20, 22]. GitHub Actions ejecutará el trabajo build tres veces, una por cada valor.
  • ${{ matrix.node-version }}: Esta sintaxis te permite acceder al valor actual de la matriz en tus pasos.

Guarda el archivo (Ctrl+S o Cmd+S) después de realizar los cambios.

Actualizar setup-node y el nombre del artefacto para usar el contexto de la matriz

Definir la matriz es solo la mitad de la batalla; también necesitamos indicar a los pasos que usen el valor actual de la matriz. Hacemos esto utilizando el contexto ${{ matrix.node-version }}.

También debemos asegurarnos de que los artefactos subidos por cada trabajo paralelo tengan nombres únicos, de lo contrario se sobrescribirán entre sí.

  1. En .github/workflows/matrix-build.yml, verifica que el paso Use Node.js utilice la variable de la matriz:
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}
  1. Verifica que el paso Upload build artifact incluya la versión de la matriz en el nombre del artefacto:
- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist
  1. Tu archivo de flujo de trabajo completo debería verse así:
name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Guarda el archivo (Ctrl+S o Cmd+S).

Confirmar, subir y observar trabajos paralelos

Veamos la matriz en acción confirmando (committing) tus cambios en GitHub.

  1. Asegúrate de estar en el directorio del repositorio:
cd ~/project/github-actions-demo
  1. Prepara (Stage) los cambios:
git add .
  1. Confirma los cambios:
git commit -m "Add matrix strategy for Node.js versions"
  1. Envía (Push) los cambios al repositorio remoto en GitHub:
git push

Nota sobre la Autenticación: Cuando ejecutes git push, el WebIDE te pedirá automáticamente que te autentiques. Sigue estos pasos detallados:

  1. Aparecerá una ventana emergente con el mensaje: "The extension 'GitHub' wants to sign in using GitHub." Haz clic en Allow.
  2. Aparecerá una nueva notificación. Haz clic en "Copy&Continue to GitHub", y luego haz clic en "Open" en el siguiente aviso.
  3. Inicia sesión en tu cuenta de GitHub en la ventana del navegador que se abre e introduce el código de autorización que se copió. Después de confirmar la autorización, la página se cerrará automáticamente.
  4. Espera unos segundos y verás que la terminal completa la operación de push con éxito.

Nota de Privacidad: El WebIDE solicitará acceso completo a tu cuenta de GitHub con fines de autenticación. No tienes que preocuparte por problemas de privacidad: la VM de LabEx se destruirá inmediatamente después de completar el laboratorio actual, y tus credenciales e información de autorización no se conservarán.

Este proceso de autenticación no requiere la configuración manual del nombre de usuario o del Personal Access Token (Token de Acceso Personal).

Verificar en GitHub

  1. Visita tu repositorio en GitHub en un navegador web.
  2. Haz clic en la pestaña Actions.
  3. Haz clic en la ejecución de flujo de trabajo (workflow run) más reciente.
  4. En la barra lateral izquierda (o en la vista de gráfico principal), ahora verás tres trabajos separados listados bajo el grupo build:
    • build (18)
    • build (20)
    • build (22)
  5. Se ejecutarán en paralelo (o casi en paralelo). Puedes hacer clic en cada uno para ver que Use Node.js configuró la versión específica solicitada.

GitHub Actions matrix builds

Resumen

En este laboratorio, aprendió a utilizar la Estrategia de Matriz (Matrix Strategy) en GitHub Actions. Usted:

  1. Definió una matriz con múltiples versiones de Node.js usando strategy: matrix.
  2. Actualizó los pasos de su flujo de trabajo para usar dinámicamente la versión desde el contexto de la matriz (${{ matrix.node-version }}).
  3. Aseguró que los nombres de los artefactos fueran únicos para cada trabajo de la matriz.

Esta potente característica le permite validar su proyecto contra una amplia gama de configuraciones con muy poca duplicación de código.

Relacionado Git Cursos
Git para Principiantes

Git para Principiantes

git
GitHub Actions para Principiantes

GitHub Actions para Principiantes

gitdevops
Instalación de un servidor Git

Instalación de un servidor Git

git